diff --git a/.eslintrc.js b/.eslintrc.js
index c14d0119..a38c5e1b 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -4,7 +4,7 @@ module.exports = {
         "commonjs": true,
         "es6": true,
         "node": true
-    },
+	},
     "extends": "eslint:recommended",
     "rules": {
         "accessor-pairs": "error",
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index ab8484ef..6485e4d6 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,6 +1,3 @@
-# Leo owns everything, for better or worse
-*   @lhorie
-
 .travis.yml     @tivac
 package.json    @tivac
 .npmignore      @tivac
@@ -9,4 +6,4 @@ package.json    @tivac
 README.md       @tivac
 docs/           @tivac
 performance/    @tivac
-render/         @isiahmeadows
+render/         @isiahmeadows @pygy
diff --git a/README.md b/README.md
index 105894ed..e797acf0 100644
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ mithril.js [![NPM Version](https://img.shields.io/npm/v/mithril.svg)](https://ww
 
 ## What is Mithril?
 
-A modern client-side Javascript framework for building Single Page Applications. It's small (<!-- size -->8.43 KB<!-- /size --> gzipped), fast and provides routing and XHR utilities out of the box.
+A modern client-side Javascript framework for building Single Page Applications. It's small (<!-- size -->8.59 KB<!-- /size --> gzipped), fast and provides routing and XHR utilities out of the box.
 
 Mithril is used by companies like Vimeo and Nike, and open source platforms like Lichess 👍.
 
diff --git a/api/router.js b/api/router.js
index 40ccb7cd..4d893acc 100644
--- a/api/router.js
+++ b/api/router.js
@@ -52,7 +52,7 @@ module.exports = function($window, redrawService) {
 	}
 	route.get = function() {return currentPath}
 	route.prefix = function(prefix) {routeService.prefix = prefix}
-	route.link = function(vnode) {
+	var link = function(options, vnode) {
 		vnode.dom.setAttribute("href", routeService.prefix + vnode.attrs.href)
 		vnode.dom.onclick = function(e) {
 			if (e.ctrlKey || e.metaKey || e.shiftKey || e.which === 2) return
@@ -60,9 +60,13 @@ module.exports = function($window, redrawService) {
 			e.redraw = false
 			var href = this.getAttribute("href")
 			if (href.indexOf(routeService.prefix) === 0) href = href.slice(routeService.prefix.length)
-			route.set(href, undefined, undefined)
+			route.set(href, undefined, options)
 		}
 	}
+	route.link = function(args) {
+		if (args.tag == null) return link.bind(link, args)
+		return link({}, args)
+	}
 	route.param = function(key) {
 		if(typeof attrs !== "undefined" && typeof key !== "undefined") return attrs[key]
 		return attrs
diff --git a/api/tests/test-router.js b/api/tests/test-router.js
index 69aff4ca..f5336625 100644
--- a/api/tests/test-router.js
+++ b/api/tests/test-router.js
@@ -281,6 +281,36 @@ o.spec("route", function() {
 					o($window.location.href).equals(env.protocol + "//" + (env.hostname === "/" ? "" : env.hostname) + slash + (prefix ? prefix + "/" : "") + "test")
 				})
 
+				o("passes options on route.link", function() {
+					var opts = {}
+					var e = $window.document.createEvent("MouseEvents")
+
+					e.initEvent("click", true, true)
+					$window.location.href = prefix + "/"
+
+					route(root, "/", {
+						"/" : {
+							view: function() {
+								return m("a", {
+									href: "/test",
+									oncreate: route.link(opts)
+								})
+							}
+						},
+						"/test" : {
+							view : function() {
+								return m("div")
+							}
+						}
+					})
+					route.set = o.spy(route.set)
+
+					root.firstChild.dispatchEvent(e)
+
+					o(route.set.callCount).equals(1)
+					o(route.set.args[2]).equals(opts)
+				})
+
 				o("accepts RouteResolver with onmatch that returns Component", function(done) {
 					var matchCount = 0
 					var renderCount = 0
diff --git a/bundler/minify.js b/bundler/minify.js
index 51b2b775..3b1d3cae 100644
--- a/bundler/minify.js
+++ b/bundler/minify.js
@@ -1,6 +1,6 @@
 "use strict"
 
-var http = require("http")
+var http = require("https")
 var querystring = require("querystring")
 var fs = require("fs")
 
@@ -22,7 +22,6 @@ module.exports = function(input, output, options, done) {
 		var response = ""
 		var req = http.request({
 			method: "POST",
-			protocol: "http:",
 			hostname: "closure-compiler.appspot.com",
 			path: "/compile",
 			headers: {
@@ -33,8 +32,16 @@ module.exports = function(input, output, options, done) {
 			res.on("data", function(chunk) {
 				response += chunk.toString()
 			})
+
 			res.on("end", function() {
-				var results = JSON.parse(response)
+				try {
+					var results = JSON.parse(response)
+				} catch(e) {
+					console.error(response);
+
+					throw e;
+				}
+
 				if (results.errors) {
 					for (var i = 0; i < results.errors.length; i++) console.log(results.errors[i])
 				}
diff --git a/docs/change-log.md b/docs/change-log.md
index 3873c6b8..25e0a231 100644
--- a/docs/change-log.md
+++ b/docs/change-log.md
@@ -1,7 +1,9 @@
 # Change log
 
 - [v2.0.0](#v200-wip)
-- [v1.1.4](#v113)
+- [v1.1.6](#v116)
+- [v1.1.5](#v115)
+- [v1.1.4](#v114)
 - [v1.1.3](#v113)
 - [v1.1.2](#v112)
 - [v1.1.1](#v111)
@@ -18,27 +20,58 @@
 
 - API: `m.redraw()` is always asynchronous ([#1592](https://github.com/MithrilJS/mithril.js/pull/1592))
 - API: `m.mount()` will only render its own root when called, it will not trigger a `redraw()` ([#1592](https://github.com/MithrilJS/mithril.js/pull/1592))
+- API: Assigning to `vnode.state` (as in `vnode.state = ...`) is no longer supported. Instead, an error is thrown if `vnode.state` changes upon the invocation of a lifecycle hook.
+- API: `m.request` will no longer reject the Promise on server errors (eg. status >= 400) if the caller supplies an `extract` callback. This gives applications more control over handling server responses.
 
 #### News
 
 - API: Introduction of `m.redraw.sync()` ([#1592](https://github.com/MithrilJS/mithril.js/pull/1592))
 - API: Event handlers may also be objects with `handleEvent` methods ([#1939](https://github.com/MithrilJS/mithril.js/issues/1939)).
+- API: `m.route.link` accepts an optional `options` object ([#1930](https://github.com/MithrilJS/mithril.js/pull/1930))
+- API: `m.request` supports `timeout` as attr - ([#1966](https://github.com/MithrilJS/mithril.js/pull/1966))
 
-#### Ospec improvements:
-
-- Added support for async functions and promises in tests - ([#1928](https://github.com/MithrilJS/mithril.js/pull/1928))
-- Error handling for async tests with `done` callbacks supports error as first argument
 
 #### Bug fixes
 
 - API: `m.route.set()` causes all mount points to be redrawn ([#1592](https://github.com/MithrilJS/mithril.js/pull/1592))
-- API: If a user sets the Content-Type header within a request's options, that value will be the entire header value rather than being appended to the default value ([#1924](https://github.com/MithrilJS/mithril.js/pull/1924))
 - API: Using style objects in hyperscript calls will now properly diff style properties from one render to another as opposed to re-writing all element style properties every render.
 - core: `addEventListener` and `removeEventListener` are always used to manage event subscriptions, preventing external interference.
 - core: Event listeners allocate less memory, swap at low cost, and are properly diffed now when rendered via `m.mount()`/`m.redraw()`.
 - core: `Object.prototype` properties can no longer interfere with event listener calls.
 - API: Event handlers, when set to literally `undefined` (or any non-function), are now correctly removed.
 - core: `xlink:href` attributes are now correctly removed
+- render: fixed an ommission that caused `oninit` to be called unnecessarily in some cases [#1992](https://github.com/MithrilJS/mithril.js/issues/1992)
+- render: Render state correctly on select change event [#1916](https://github.com/MithrilJS/mithril.js/issues/1916)
+- render: fix various updateNodes/removeNodes issues when the pool and fragments are involved [#1990](https://github.com/MithrilJS/mithril.js/issues/1990), [#1991](https://github.com/MithrilJS/mithril.js/issues/1991), [#2003](https://github.com/MithrilJS/mithril.js/issues/2003), [#2021](https://github.com/MithrilJS/mithril.js/pull/2021)
+
+---
+
+### v1.1.6
+
+- core: render() function can no longer prevent from changing `document.activeElement` in lifecycle hooks ([#1988](https://github.com/MithrilJS/mithril.js/pull/1988), [@purplecode](https://github.com/purplecode))
+- core: don't call `onremove` on the children of components that return null from the view [#1921](https://github.com/MithrilJS/mithril.js/issues/1921) [@octavore](https://github.com/octavore) ([#1922](https://github.com/MithrilJS/mithril.js/pull/1922))
+- hypertext: correct handling of shared attributes object passed to `m()`. Will copy attributes when it's necessary [#1941](https://github.com/MithrilJS/mithril.js/issues/1941) [@s-ilya](https://github.com/s-ilya) ([#1942](https://github.com/MithrilJS/mithril.js/pull/1942))
+
+#### Ospec improvements
+
+- ospec v1.4.0
+  - Added support for async functions and promises in tests ([#1928](https://github.com/MithrilJS/mithril.js/pull/1928), [@StephanHoyer](https://github.com/StephanHoyer))
+  - Error handling for async tests with `done` callbacks supports error as first argument ([#1928](https://github.com/MithrilJS/mithril.js/pull/1928))
+  - Error messages which include newline characters do not swallow the stack trace [#1495](https://github.com/MithrilJS/mithril.js/issues/1495) ([#1984](https://github.com/MithrilJS/mithril.js/pull/1984), [@RodericDay](https://github.com/RodericDay))
+- ospec v2.0.0 (to be released)
+  - Added support for custom reporters ([#2009](https://github.com/MithrilJS/mithril.js/pull/2020))
+  - Make Ospec more [Flems](https://flems.io)-friendly ([#2034](https://github.com/MithrilJS/mithril.js/pull/2034))
+    - Works either as a global or in CommonJS environments
+    - the o.run() report is always printed asynchronously (it could be synchronous before if none of the tests were async).
+    - Properly point to the assertion location of async errors [#2036](https://github.com/MithrilJS/mithril.js/issues/2036)
+    - expose the default reporter as `o.report(results)`
+    - Don't try to access the stack traces in IE9
+
+---
+
+### v1.1.5
+
+- API: If a user sets the Content-Type header within a request's options, that value will be the entire header value rather than being appended to the default value ([#1924](https://github.com/MithrilJS/mithril.js/pull/1924))
 
 ---
 
@@ -46,9 +79,7 @@
 
 #### Bug fixes:
 
-- core: don't call `onremove` on the children of components that return null from the view [#1921](https://github.com/MithrilJS/mithril.js/issues/1921) [octavore](https://github.com/octavore) ([#1922](https://github.com/MithrilJS/mithril.js/pull/1922))
-- hypertext: correct handling of shared attributes object passed to `m()`. Will copy attributes when it's necessary [#1941](https://github.com/MithrilJS/mithril.js/issues/1941) [s-ilya](https://github.com/s-ilya) ([#1942](https://github.com/MithrilJS/mithril.js/pull/1942))
-- Fix IE bug where active element is null causing render function to throw error. ([1943](https://github.com/MithrilJS/mithril.js/pull/1943))
+- Fix IE bug where active element is null causing render function to throw error ([#1943](https://github.com/MithrilJS/mithril.js/pull/1943), [@JacksonJN](https://github.com/JacksonJN))
 
 #### Ospec improvements:
 
diff --git a/docs/code-of-conduct.md b/docs/code-of-conduct.md
index 50ebe61d..a8875af5 100644
--- a/docs/code-of-conduct.md
+++ b/docs/code-of-conduct.md
@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at [github@patcavit.com](mailto:github@patcavit.com?subject=Mithril Code of Conduct). All
+reported by contacting the project team at [github@patcavit.com](mailto:github@patcavit.com?subject=Mithril%20Code%20of%20Conduct). All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
diff --git a/docs/installation.md b/docs/installation.md
index c4604ad5..57efabe6 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -17,28 +17,48 @@ If you're new to Javascript or just want a very simple setup to get your feet we
 
 #### Quick start with Webpack
 
+
+1. Initialize the directory as an npm package
 ```bash
-# 1) install
-npm install mithril --save
-
-npm install webpack --save
-
-# 2) add this line into the scripts section in package.json
-#	"scripts": {
-#		"start": "webpack src/index.js bin/app.js --watch"
-#	}
-
-# 3) create an `src/index.js` file
-
-# 4) create an `index.html` file containing `<script src="bin/app.js"></script>`
-
-# 5) run bundler
-npm start
-
-# 6) open `index.html` in the (default) browser
-open index.html
+$> npm init --yes
 ```
 
+2. install required tools
+```bash
+$> npm install mithril --save
+$> npm install webpack --save
+```
+
+3. Add a "start" entry to the scripts section in `package.json`
+```js
+{
+  // ...
+  "scripts": {
+    "start": "webpack src/index.js bin/app.js --watch"
+  }
+}
+```
+
+3. Create `src/index.js`
+```js
+import m from "mithril";
+
+m.render(document.body, "hello world");
+```
+
+4. create `index.html`
+```html
+<!DOCTYPE html>
+
+<script src="bin/app.js"></script>
+```
+
+5. run bundler
+```bash
+$> npm start
+```
+6. open `index.html` in your (default) browser
+
 #### Step by step
 
 For production-level projects, the recommended way of installing Mithril is to use NPM.
diff --git a/docs/integrating-libs.md b/docs/integrating-libs.md
new file mode 100644
index 00000000..42b72bee
--- /dev/null
+++ b/docs/integrating-libs.md
@@ -0,0 +1,57 @@
+# Integrating with Other Libraries
+Integration with third party libraries or vanilla javascript code can be achieved via [lifecycle methods](lifecycle-methods.md).
+
+- [Usage](#usage)
+
+### Usage
+```javascript
+var FullCalendar = {
+
+	oncreate: function (vnode) {
+		console.log('FullCalendar::oncreate')
+		$(vnode.dom).fullCalendar({
+			// put your initial options and callbacks here
+		})
+
+		Object.assign(vnode.attrs.parentState, {fullCalendarEl: vnode.dom})
+	},
+
+	// Consider that the lib will modify this parent element in the DOM (e.g. add dependent class attribute and values).
+	// As long as you return the same view results here, mithril will not
+	// overwrite the actual DOM because it's always comparing old and new VDOM
+	// before applying DOM updates. 
+	view: function (vnode) {
+		return m('div')
+	},
+
+	onbeforeremove: function (vnode) {
+		// Run any destroy / cleanup methods here.
+		//E.g. $(vnode.state.fullCalendarEl).fullCalendar('destroy')
+	}
+}
+
+m.mount(document.body, {
+	view: function (vnode) {
+		return [
+			m('h1', 'Calendar'),
+			m(FullCalendar, {parentState: vnode.state}),
+			m('button', {onclick: prev}, 'Mithril Button -'),
+			m('button', {onclick: next}, 'Mithril Button +')
+
+		]
+
+		function next() {
+			$(vnode.state.fullCalendarEl).fullCalendar('next')
+		}
+
+		function prev() {
+			$(vnode.state.fullCalendarEl).fullCalendar('prev')
+		}
+
+	}
+
+})
+
+```
+
+Running example [flems: FullCalendar](https://flems.io/#0=N4IgZglgNgpgziAXAbVAOwIYFsZJAOgAsAXLKEAGhAGMB7NYmBvAHigjQGsACAJxigBeADog4xAJ6w4hGDGKjuhfmBEgSxAA5xEAel3UAJmgBWcfNSi0ArobBQM-C7Sy6MJjAA9d7AEZxdMGsoKGoMWDRDR10AZnwAdnwABkDg0PCmKN58LA4LODhRAD4QAF8KdGxcRAIzShp6RmYagDdHbgAxNIBhDMj2wW5gYTQR4WJ6an4MRkRuILRqYgh6bgAKFrRaQxgASiGxhWI6NDhaWHwrAHM1gHIukN6oft5EREnpxlvdw-GAEg2Wx2+EMLl2+CCjz6WTWw1GR3G+m4mmsxG4EhsvG4HAgy3C3FommW9Dg3AwkW4YRCvgw1E4pNk-F+xFKP1G8PGAHlfCYYEt8BgChArmhAdsYALiMReOZNI4mMQAMrEGYwChDSFQJ6ZRwAUSgc024pBLlZh3KY3hLQgMAA7nMFksVmh1kadvs4eNxvxiNZeC6sHdDBAWt9zRRLeN6L4YGBaPx+FhaC0YA7rItiS6xe6DhziEiAErpsloCTcHbiXi0Mu6SmwcnWTTcHDEQjbBkwJzM-QAt0S8SqiE9aF6qDgzXal5B+DS6th+GlEaL9lYHI2BhrUHUaw4Bj4XzbCTqz3Ea12tMZ52uoF7XNe6XyP0u5DM8aB26EACMt3Vt0nWW+CM8zfNYHi1EdeGPOV+AYZVVUNG98AHRhWSA+8QNuXxUQmNAfzvBEjkmdg6TmTR+BaV8WV-ABZXFlGgbgACFsNWABaQDKPfLCpXoPCT3QnDLAgEjuDQGBPAUYCqO4W5aNbXgGOYniXQAannZkAF1IyOR1M1E8TiDWD1KN7RDkIlCcIP1cdhwiGFbjEiT1KOZdmV0q8yJgFojPw+9TONcyhyhOzRxs4KdV4O5PNDNl71chdLVZMoKhATAcDwfIECoE4mmIPAyg0qh2C4BAUEqdKalyeToHqP1yBqDRtD0XR000TgrmcVwqvoqAAAFP3wAaAFZdG6hSoHwOoqEkTRqhAOpynKuak13PKqDqvBGp0fRWvazrRpcBVeoAJkGgBOfBjoO1bJqykAZrmhaUrSx6AEdrE7CRat4er1ClJqdrQNqOroVwTHez7eriU7P10YNxF0cGPt4CRbvqB68Cepa8E1KkIu+36tua3aQZcVIQjxl4oYSZI4YgBHcYgtHpokWbMYQUoNNKIA)
\ No newline at end of file
diff --git a/docs/learning-mithril.md b/docs/learning-mithril.md
new file mode 100644
index 00000000..fb599df8
--- /dev/null
+++ b/docs/learning-mithril.md
@@ -0,0 +1,5 @@
+# Learning Mithril
+
+Links to Mithril learning content:
+
+- [Mithril 0-60](https://scrimba.com/playlist/playlist-34)
diff --git a/docs/nav-guides.md b/docs/nav-guides.md
index 872ce86b..4a5be9df 100644
--- a/docs/nav-guides.md
+++ b/docs/nav-guides.md
@@ -9,6 +9,7 @@
 	- [Animation](animation.md)
 	- [Testing](testing.md)
 	- [Examples](examples.md)
+	- [Learning Mithril](learning-mithril.md)	
 - Key concepts
 	- [Vnodes](vnodes.md)
 	- [Components](components.md)
diff --git a/docs/releasing.md b/docs/releasing.md
index 37bec28d..ce4a871d 100644
--- a/docs/releasing.md
+++ b/docs/releasing.md
@@ -2,6 +2,10 @@
 
 **Note** These steps all assume that `MithrilJS/mithril.js` is a git remote named `mithriljs`, adjust accordingly if that doesn't match your setup.
 
+- [Releasing a new Mithril version](#releasing-a-new-mithril-version)
+- [Updating mithril.js.org](#updating-mithriljsorg)
+- [Releasing a new ospec version](#releasing-a-new-ospec-version)
+
 ## Releasing a new Mithril version
 
 ### Prepare the release
@@ -112,3 +116,61 @@ $ git push mithriljs
 ```
 
 After the Travis build completes the updated docs should appear on https://mithril.js.org in a few minutes.
+
+## Releasing a new ospec version
+
+1. Ensure your local branch is up to date
+
+```bash
+$ git co next
+$ git pull --rebase mithriljs next
+```
+
+2. Determine patch level of the change
+3. Update `version` field in `ospec/package.json` to match new version being prepared for release
+4. Commit changes to `next`
+
+```
+$ git add .
+$ git commit -m "chore(ospec): ospec@<version>"
+
+# Push to your branch
+$ git push
+
+# Push to MithrilJS/mithril.js
+$ git push mithriljs next
+```
+
+### Merge from `next` to `master`
+
+5. Switch to `master` and make sure it's up to date
+
+```bash
+$ git co master
+$ git pull --rebase mithriljs master
+```
+
+6. merge `next` on top of it
+
+```bash
+$ git checkout next -- ./ospec
+$ git add .
+$ git commit -m "chore(ospec): ospec@<version>"
+```
+
+7. Ensure the tests are passing!
+
+### Publish the release
+
+8. Push the changes to `MithrilJS/mithril.js`
+
+```bash
+$ git push mithriljs master
+```
+
+9. Publish the changes to npm **from the `/ospec` folder**. That bit is important to ensure you don't accidentally ship a new Mithril release!
+
+```bash
+$ cd ./ospec
+$ npm publish
+```
diff --git a/docs/request.md b/docs/request.md
index fe962e50..44bb954b 100644
--- a/docs/request.md
+++ b/docs/request.md
@@ -49,12 +49,13 @@ Argument                  | Type                              | Required | Descr
 `options.user`            | `String`                          | No       | A username for HTTP authorization. Defaults to `undefined`.
 `options.password`        | `String`                          | No       | A password for HTTP authorization. Defaults to `undefined`. This option is provided for `XMLHttpRequest` compatibility, but you should avoid using it because it sends the password in plain text over the network.
 `options.withCredentials` | `Boolean`                         | No       | Whether to send cookies to 3rd party domains. Defaults to `false`
+`options.timeout`         | `Number`                          | No       | The amount of milliseconds a request can take before automatically being [terminated](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/timeout).  Defaults to `undefined`.
 `options.config`          | `xhr = Function(xhr)`             | No       | Exposes the underlying XMLHttpRequest object for low-level configuration. Defaults to the [identity function](https://en.wikipedia.org/wiki/Identity_function).
 `options.headers`         | `Object`                          | No       | Headers to append to the request before sending it (applied right before `options.config`).
 `options.type`            | `any = Function(any)`             | No       | A constructor to be applied to each object in the response. Defaults to the [identity function](https://en.wikipedia.org/wiki/Identity_function).
 `options.serialize`       | `string = Function(any)`          | No       | A serialization method to be applied to `data`. Defaults to `JSON.stringify`, or if `options.data` is an instance of [`FormData`](https://developer.mozilla.org/en/docs/Web/API/FormData), defaults to the [identity function](https://en.wikipedia.org/wiki/Identity_function) (i.e. `function(value) {return value}`).
 `options.deserialize`     | `any = Function(string)`          | No       | A deserialization method to be applied to the `xhr.responseText`. Defaults to a small wrapper around `JSON.parse` that returns `null` for empty responses. If `extract` is defined, `deserialize` will be skipped.
-`options.extract`         | `any = Function(xhr, options)`    | No       | A hook to specify how the XMLHttpRequest response should be read. Useful for processing response data, reading headers and cookies. By default this is a function that returns `xhr.responseText`, which is in turn passed to `deserialize`. If a custom `extract` callback is provided, the `xhr` parameter is the XMLHttpRequest instance used for the request, and `options` is the object that was passed to the `m.request` call. Additionally, `deserialize` will be skipped and the value returned from the extract callback will not automatically be parsed as JSON.
+`options.extract`         | `any = Function(xhr, options)`    | No       | A hook to specify how the XMLHttpRequest response should be read. Useful for processing response data, reading headers and cookies. By default this is a function that returns `xhr.responseText`, which is in turn passed to `deserialize`. If a custom `extract` callback is provided, the `xhr` parameter is the XMLHttpRequest instance used for the request, and `options` is the object that was passed to the `m.request` call. Additionally, `deserialize` will be skipped and the value returned from the extract callback will be left as-is when the promise resolves. Furthermore, when an extract callback is provided, exceptions are *not* thrown when the server response status code indicates an error.
 `options.useBody`         | `Boolean`                         | No       | Force the use of the HTTP body section for `data` in `GET` requests when set to `true`, or the use of querystring for other HTTP methods when set to `false`. Defaults to `false` for `GET` requests and `true` for other methods.
 `options.background`      | `Boolean`                         | No       | If `false`, redraws mounted components upon completion of the request. If `true`, it does not. Defaults to `false`.
 **returns**               | `Promise`                         |          | A promise that resolves to the response data, after it has been piped through the `extract`, `deserialize` and `type` methods
@@ -81,6 +82,8 @@ A call to `m.request` returns a [promise](promise.md) and triggers a redraw upon
 
 By default, `m.request` assumes the response is in JSON format and parses it into a Javascript object (or array).
 
+If the HTTP response status code indicates an error, the returned Promise will be rejected. Supplying an extract callback will prevent the promise rejection.
+
 ---
 
 ### Typical usage
@@ -426,7 +429,7 @@ m.request({
 
 ### Retrieving response details
 
-By default Mithril attempts to parse a response as JSON and returns `xhr.responseText`. It may be useful to inspect a server response in more detail, this can be accomplished by passing a custom `options.extract` function:
+By default Mithril attempts to parse `xhr.responseText` as JSON and returns the parsed object. It may be useful to inspect a server response in more detail and process it manually. This can be accomplished by passing a custom `options.extract` function:
 
 ```javascript
 m.request({
diff --git a/docs/route.md b/docs/route.md
index 73b0e395..712c6845 100644
--- a/docs/route.md
+++ b/docs/route.md
@@ -104,7 +104,7 @@ Argument          | Type      | Required | Description
 This function can be used as the `oncreate` (and `onupdate`) hook in a `m("a")` vnode:
 
 ```JS
-m("a[href=/]", {oncreate: m.route.link})`.
+m("a[href=/]", {oncreate: m.route.link})
 ```
 
 Using `m.route.link` as a `oncreate` hook causes the link to behave as a router link (i.e. it navigates to the route specified in `href`, instead of navigating away from the current page to the URL specified in `href`.
@@ -112,15 +112,21 @@ Using `m.route.link` as a `oncreate` hook causes the link to behave as a router
 If the `href` attribute is not static, the `onupdate` hook must also be set:
 
 ```JS
-m("a", {href: someVariable, oncreate: m.route.link, onupdate: m.route.link})`
+m("a", {href: someVariable, oncreate: m.route.link, onupdate: m.route.link})
 ```
 
-`m.route.link(vnode)`
+`m.route.link` can also set the `options` passed to `m.route.set` when the link is clicked by calling the function in the lifecycle methods:
 
-Argument          | Type        | Required | Description
------------------ | ----------- | -------- | ---
-`vnode`           | `Vnode`     | Yes      | This method is meant to be used as or in conjunction with an `<a>` [vnode](vnodes.md)'s [`oncreate` and `onupdate` hooks](lifecycle-methods.md)
-**returns**       |             |          | Returns `undefined`
+```JS
+m("a[href=/]", {oncreate: m.route.link({replace: true})})
+```
+
+`m.route.link(args)`
+
+Argument          | Type           | Required | Description
+----------------- | ---------------| -------- | ---
+`args`            | `Vnode|Object` | Yes      | This method is meant to be used as or in conjunction with an `<a>` [vnode](vnodes.md)'s [`oncreate` and `onupdate` hooks](lifecycle-methods.md)
+**returns**       | `function`     |          | Returns the onclick handler function for the component
 
 ##### m.route.param
 
@@ -588,7 +594,7 @@ m.route(document.body, "/secret", {
 
 #### Preloading data
 
-Typically, a component can load data upon initialization. Loading data this way renders the component twice (once upon routing, and once after the request completes).
+Typically, a component can load data upon initialization. Loading data this way renders the component twice. The first render pass occurs upon routing, and the second fires after the request completes. Take care to note that `loadUsers()` returns a Promise, but any Promise returned by `oninit` is currently ignored. The second render pass comes from the [`background` option for `m.request`](request.md).
 
 ```javascript
 var state = {
diff --git a/docs/simple-application.md b/docs/simple-application.md
index cd943cc8..9ca3a698 100644
--- a/docs/simple-application.md
+++ b/docs/simple-application.md
@@ -2,6 +2,8 @@
 
 Let's develop a simple application that covers some of the major aspects of Single Page Applications
 
+An interactive running example can be seen here [flems: Simple Application](https://flems.io/#0=N4IgzgpgNhDGAuEAmIBcICGAHLA6AVmCADQgBmAljEagNqgB2GAthGiAKqQBOAsgPZJoBIqVj8GiSewBuGbgAIuERQF4FwADoMFuhVAph4qBbQC6xbXv38MSADKHjCsgFcGCChIAUASg1W1nrcEPCu3DrMuCEAjq4QRt5aOkGprPAAFoImmiAA4gCiACq5limp1uFQOSAZ8PBYYKgA9M0hzAC0IUYd2BS4GSr8ANau2HjizM19za48YKWBFXoA7hSZAMIhQpIUGFBNCvDc8WXLAL6+S0G4mRAM3m4e8F4P3a5Q8P7Jy9bK3LgDEYFOp3p9cEgMPAMNdrJdrucytdYOEQpITMBEdcoLYkCYnp4fBQkN9YcFQuFItEIHEEvAkmS0qEsniFLlCiUSIyglUanUGk1Wu0unTelh+oNuCMxjhcJNpuLZvNmrkFABqBTEs6-XRrTbbe4vfaHY6nbnw8o3O4PAkvHxgr4BS3Lf5y1GGkEKB3mq6WrEMa5gDAyCD49yEh6k53ksIRBRRWLxRI-HXx5nZNkgAAKHE52p1vMz-MaLTaEE63XgYolQ1G4zl-CmMzmKjAKpA6qUPDd3DR8FwWu51kh0JMrpRvcN+d+eoyW2Qhr2BxMpog07hvrh2nOIERjBYbHQ-0cRhEJBA4kkhtk8i7KhP8E9Kd0EgoDHWY+7OLsD+nMgoEArGGzyvH4TrLCEsaRN4uS4C23AdEC8ClHeAJIbgzDYI84Z2g88FRqmXoUnGzAwZgcE8IhTgdOs5YocAGQhGQNTNMg6ztp28EDkgxAKBIsAhFCobxtE-CuIggJvsMiIKFxlDcEYAByB6dqqqoalxUAYEpB6bhUlx6bo5zbruxD7qw7D-AAYvw3BRIQ56XlI8A3oo1m2cwT7XK+77OLaoEyAwggQN8rrfkg3iBcFuBQscYDcb4-rWP+gHARGYHPkEkGUvGZFkB59FDhUEhgK4ABGzAfi4OGgSF4GERUEC4FgIQhpIAAiEBkBgHz0oZDV-N2QYhn4RWpMZ0bjbxtBjbluRaWVwgLdAKG5FZFAKY+TCsLkvjrhUpG5G+WDiQODAnfAtDwAAnlgECqIgAAe8BmLQWBabAEBZFAQjcKo62bQo20QGYhWTb8PkXSYUSzgAgvU3BkXIUDxCh-k+Mj8Shd2E59rg8k6awnqYxAlz7TqJOfioPZ4wT8DKTt4MbuTQSHSAy1QICGCLVAq0gPY2lbQeu0s9YbPHadEuXe9GCfd9v2qALwLA6DJD1QNkPidDuBwwjSP7Kjavow8JPY9TuOGlzhMQMTBuk3ts3JXbVMAhbkhW-TwtM3oZOzWzZXifAEi4AH9QSFdt33aVFXrKrvG5AAysGEAi9yZj9RNO57iAwPsAL11if2DliBIzmuQo+eF15lopUB1UgRjQVCARFTZSRZGYW+XMF+JKEzd7uhs0wMgYfcrh947ehszCauZQNjFdSYADkzRIUvosQx4gmINrUriU1BgMMMk9GfHnDzLts3pxvg9kZAEYoVFQhyhkVBIGi-XWOnCImdnufoPWYuF5S7XnQAmQuTUWpdQoI9bwS8ADES9fTgP3t4JA-AUSsHdmVQQ10z6rycGDawuQCFGFyBibkaJfppVwhlWabdoKV3ErxUix4nC+E-j7BE04SFsXgM0VAxJyHqyyvcah9d0pPzqnPVuxFGEYB7vAFh3h3J2V4lImKCMwAcPNNw7cvhTLmUPCAOUYBRDAKvNIdAOCkB4LOhdYgIdA4SA0PldEQU7L7AUAARgAGxYEegoAAaioSETAADcmFuAAHM3wmAAEwAAYAkTW0N3KuwAomxIYKgbxyTAk9SDpEjAj0OhrCQJkXJiTqkBPCRNUeDBXAaCyXExJCg2kAGZ8l1O0Gk+CVFgTACQh0Iw10YCoCCgwCAxSYmtPaT47pWA7BIDfNE1AiSekMAoioAZVZaKeWAGVWWwxol7wYHieB3UrkYHCTg7g1DvEBIUGAfgBgkAKHgUgL54TxA4m4KgeBHSgXhJWWAGW11UBlRxLAYYMzsnrPmY8x64SllfNWagAAHE87xABWWpT0qxCHENwKErwJkSGmfU-pwz9moCyCGRQwACUdCJbZUlEhUDuF+ofSlvStkcw0KC8FkLoWwpaTktpbS8XIvqVLDQdyHlPJeW8j5XykC3Nsr9LodgKBzFQB02pODSlgAoAAL3RQqnZRqQWGGFVCjBYr5DwslQs2pqKVkMDWXk7F0rwnlMqXkxJABSTZTiw46EOcc05YlzkAogPGjV9yVC5KVa84kqrvmWoQiSlZeqDXIt+bZAFQKOk2rBVpCFb4eUdHtTCuFcy2neuRe69FTafG+uZaykluFyVTNDaHIOOT6UqHlVGs5FyIAYsnZOupu4LDsykjQegOcDzsEqpkbgVBzxVHYMWQUsxzonIbFMddjEqAAAFvG4Cvb45op7N2cyATdO67AHLnDMOcIAA)
+
 First let's create an entry point for the application. Create a file `index.html`:
 
 ```markup
diff --git a/docs/style.css b/docs/style.css
index bf0e6874..3da4e572 100644
--- a/docs/style.css
+++ b/docs/style.css
@@ -1,4 +1,4 @@
-body {-webkit-text-size-adjust: 100%;}
+body {background:white;-webkit-text-size-adjust: 100%;}
 body,table,h5 {font:normal 16px 'Open Sans';}
 header,main {margin:auto;max-width:1000px;}
 header section {position:absolute;width:250px;}
@@ -57,7 +57,7 @@ h1 + ul strong + ul {border-left:3px solid #1e5799;}
 	.hamburger:hover {text-decoration:none;}
 	main section {margin:0;}
 	header section {margin:0 0 20px;position:static;width:auto;}
-	h1 + ul {background:#eee;border:1px solid #ccc;box-sizing:border-box;display:none;height:100%;margin:0;overflow:auto;padding:20px;position:fixed;right:0;top:0;width:100%;}
+	h1 + ul {background:#eee;border:1px solid #ccc;box-sizing:border-box;display:none;height:100%;margin:0;overflow:auto;padding:20px;position:fixed;right:0;top:0;width:100%;z-index:1}
 	h1 + ul + hr {display:block;}
 	.navigating h1 + ul {display:block;}
 	.navigating {overflow:hidden;}
diff --git a/docs/support.md b/docs/support.md
new file mode 100644
index 00000000..ae466e16
--- /dev/null
+++ b/docs/support.md
@@ -0,0 +1,3 @@
+## Getting Help
+
+Mithril has an active & welcoming community on [Gitter](https://gitter.im/mithriljs/mithril.js), or feel free to ask questions on [Stack Overflow](https://stackoverflow.com/questions/tagged/mithril.js) using the `mithril.js` tag.
diff --git a/docs/testing.md b/docs/testing.md
index ba850a5b..ead11517 100644
--- a/docs/testing.md
+++ b/docs/testing.md
@@ -74,7 +74,9 @@ var m = require("mithril")
 
 module.exports = {
 	view: function() {
-		return m("div", "Hello world")
+		return m("div", 
+		    m("p", "Hello World")
+		)
 	}
 }
 ```
@@ -90,7 +92,7 @@ o.spec("MyComponent", function() {
 		
 		o(vnode.tag).equals("div")
 		o(vnode.children.length).equals(1)
-		o(vnode.children[0].tag).equals("#")
+		o(vnode.children[0].tag).equals("p")
 		o(vnode.children[0].children).equals("Hello world")
 	})
 })
diff --git a/docs/vnodes.md b/docs/vnodes.md
index cff0ebe4..783f432f 100644
--- a/docs/vnodes.md
+++ b/docs/vnodes.md
@@ -74,7 +74,6 @@ Property   | Type                             | Description
 `dom`      | `Element?`                       | Points to the element that corresponds to the vnode. This property is `undefined` in the `oninit` lifecycle method. In fragments and trusted HTML vnodes, `dom` points to the first element in the range.
 `domSize`  | `Number?`                        | This is only set in fragment and trusted HTML vnodes, and it's `undefined` in all other vnode types. It defines the number of DOM elements that the vnode represents (starting from the element referenced by the `dom` property).
 `state`    | `Object?`                        | An object that is persisted between redraws. It is provided by the core engine when needed. In POJO component vnodes, the `state` inherits prototypically from the component object/class. In class component vnodes it is an instance of the class. In closure components it is the object returned by the closure.
-`_state`   | `Object?`                        | For components, a reference to the original `vnode.state` object, used to lookup the `view` and hooks. This property is only used internally by Mithril, do not use or modify it.
 `events`   | `Object?`                        | An object that is persisted between redraws and that stores event handlers so that they can be removed using the DOM API. The `events` property is `undefined` if there are no event handlers defined. This property is only used internally by Mithril, do not use or modify it.
 `instance` | `Object?`                        | For components, a storage location for the value returned by the `view`. This property is only used internally by Mithril, do not use or modify it.
 `skip`     | `Boolean`                        | This property is only used internally by Mithril when diffing keyed lists, do not use or modify it.
@@ -89,7 +88,7 @@ The `tag` property of a vnode determines its type. There are five vnode types:
 Vnode type   | Example                        | Description
 ------------ | ------------------------------ | ---
 Element      | `{tag: "div"}`                 | Represents a DOM element.
-Fragment     | `{tag: "[", children: []}`     | Represents a list of DOM elements whose parent DOM element may also contain other elements that are not in the fragment. When using the [`m()`](hyperscript.md) helper function, fragment vnodes can only be created by nesting arrays into the `children` parameter of `m()`. `m("[")` does not create a valid vnode. 
+Fragment     | `{tag: "[", children: []}`     | Represents a list of DOM elements whose parent DOM element may also contain other elements that are not in the fragment. When using the [`m()`](hyperscript.md) helper function, fragment vnodes can only be created by nesting arrays into the `children` parameter of `m()`. `m("[")` does not create a valid vnode.
 Text         | `{tag: "#", children: ""}`     | Represents a DOM text node.
 Trusted HTML | `{tag: "<", children: "<br>"}` | Represents a list of DOM elements from an HTML string.
 Component    | `{tag: ExampleComponent}`      | If `tag` is a Javascript object with a `view` method, the vnode represents the DOM generated by rendering the component.
diff --git a/mithril.js b/mithril.js
index a953152b..8546f584 100644
--- a/mithril.js
+++ b/mithril.js
@@ -1,7 +1,7 @@
 ;(function() {
 "use strict"
 function Vnode(tag, key, attrs0, children, text, dom) {
-	return {tag: tag, key: key, attrs: attrs0, children: children, text: text, dom: dom, domSize: undefined, state: undefined, _state: undefined, events: undefined, instance: undefined, skip: false}
+	return {tag: tag, key: key, attrs: attrs0, children: children, text: text, dom: dom, domSize: undefined, state: undefined, events: undefined, instance: undefined, skip: false}
 }
 Vnode.normalize = function(node) {
 	if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
@@ -294,6 +294,7 @@ var _8 = function($window, Promise) {
 				xhr.setRequestHeader("Accept", "application/json, text/*")
 			}
 			if (args.withCredentials) xhr.withCredentials = args.withCredentials
+			if (args.timeout) xhr.timeout = args.timeout
 			for (var key in args.headers) if ({}.hasOwnProperty.call(args.headers, key)) {
 				xhr.setRequestHeader(key, args.headers[key])
 			}
@@ -304,7 +305,7 @@ var _8 = function($window, Promise) {
 				if (xhr.readyState === 4) {
 					try {
 						var response = (args.extract !== extract) ? args.extract(xhr, args) : args.deserialize(args.extract(xhr, args))
-						if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || FILE_PROTOCOL_REGEX.test(args.url)) {
+						if (args.extract !== extract || (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || FILE_PROTOCOL_REGEX.test(args.url)) {
 							resolve(cast(args.type, response))
 						}
 						else {
@@ -398,6 +399,22 @@ var coreRenderer = function($window) {
 	function getNameSpace(vnode) {
 		return vnode.attrs && vnode.attrs.xmlns || nameSpace[vnode.tag]
 	}
+	//sanity check to discourage people from doing `vnode.state = ...`
+	function checkState(vnode, original) {
+		if (vnode.state !== original) throw new Error("`vnode.state` must not be modified")
+	}
+	//Note: the hook is passed as the `this` argument to allow proxying the
+	//arguments without requiring a full array allocation to do so. It also
+	//takes advantage of the fact the current `vnode` is the first argument in
+	//all lifecycle methods.
+	function callHook(vnode) {
+		var original = vnode.state
+		try {
+			return this.apply(original, arguments)
+		} finally {
+			checkState(vnode, original)
+		}
+	}
 	//create
 	function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) {
 		for (var i = start; i < end; i++) {
@@ -495,10 +512,9 @@ var coreRenderer = function($window) {
 			sentinel.$$reentrantLock$$ = true
 			vnode.state = (vnode.tag.prototype != null && typeof vnode.tag.prototype.view === "function") ? new vnode.tag(vnode) : vnode.tag(vnode)
 		}
-		vnode._state = vnode.state
 		if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)
-		initLifecycle(vnode._state, vnode, hooks)
-		vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode))
+		initLifecycle(vnode.state, vnode, hooks)
+		vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
 		if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
 		sentinel.$$reentrantLock$$ = null
 	}
@@ -517,85 +533,204 @@ var coreRenderer = function($window) {
 		}
 	}
 	//update
-	function updateNodes(parent, old, vnodes, recycling, hooks, nextSibling, ns) {
-		if (old === vnodes || old == null && vnodes == null) return
+	/**
+	 * @param {Element|Fragment} parent - the parent element
+	 * @param {Vnode[] | null} old - the list of vnodes of the last0 `render()` call for
+	 *                               this part of the tree
+	 * @param {Vnode[] | null} vnodes - as above, but for the current `render()` call.
+	 * @param {boolean} recyclingParent - was the parent vnode or one of its ancestor
+	 *                                    fetched from the recycling pool?
+	 * @param {Function[]} hooks - an accumulator of post-render hooks (oncreate/onupdate)
+	 * @param {Element | null} nextSibling - the next0 DOM node if we're dealing with a
+	 *                                       fragment that is not the last0 item in its
+	 *                                       parent
+	 * @param {'svg' | 'math' | String | null} ns) - the current XML namespace, if any
+	 * @returns void
+	 */
+	// This function diffs and patches lists of vnodes, both keyed and unkeyed.
+	//
+	// We will:
+	//
+	// 1. describe its general structure
+	// 2. focus on the diff algorithm optimizations
+	// 3. describe how the recycling pool meshes into this
+	// 4. discuss DOM node operations.
+	// ## Overview:
+	//
+	// The updateNodes() function:
+	// - deals with trivial cases
+	// - determines whether the lists are keyed or unkeyed
+	//   (Currently we look for the first pair of non-null nodes and deem the lists unkeyed
+	//   if both nodes are unkeyed. TODO (v2) We may later take advantage of the fact that
+	//   mixed diff is not supported and settle on the keyedness of the first vnode we find)
+	// - diffs them and patches the DOM if needed (that's the brunt of the code)
+	// - manages the leftovers: after diffing, are there:
+	//   - old nodes left to remove?
+	// 	 - new nodes to insert?
+	//   - nodes left in the recycling pool?
+	// 	 deal with them!
+	//
+	// The lists are only iterated over once, with an exception for the nodes in `old` that
+	// are visited in the fourth part of the diff and in the `removeNodes` loop.
+	// ## Diffing
+	//
+	// There's first a simple diff for unkeyed lists of equal length that eschews the pool.
+	//
+	// It is followed by a small section that activates the recycling pool if present, we'll
+	// ignore it for now.
+	//
+	// Then comes the main diff algorithm that is split in four parts (simplifying a bit).
+	//
+	// The first part goes through both lists top-down as long as the nodes at each level have
+	// the same key2. This is always true for unkeyed lists that are entirely processed by this
+	// step.
+	//
+	// The second part deals with lists reversals, and traverses one list top-down and the other
+	// bottom-up (as long as the keys match1).
+	//
+	// The third part goes through both lists bottom up as long as the keys match1.
+	//
+	// The first and third sections allow us to deal efficiently with situations where one or
+	// more contiguous nodes were either inserted into, removed from or re-ordered in an otherwise
+	// sorted list. They may reduce the number of nodes to be processed in the fourth section.
+	//
+	// The fourth section does keyed diff for the situations not covered by the other three. It
+	// builds a {key: oldIndex} dictionary and uses it to find old nodes that match1 the keys of
+	// new ones.
+	// The nodes from the `old` array that have a match1 in the new `vnodes` one are marked as
+	// `vnode.skip: true`.
+	//
+	// If there are still nodes in the new `vnodes` array that haven't been matched to old ones,
+	// they are created.
+	// The range of old nodes that wasn't covered by the first three sections is passed to
+	// `removeNodes()`. Those nodes are removed unless marked as `.skip: true`.
+	//
+	// Then some pool business happens.
+	//
+	// It should be noted that the description of the four sections above is not perfect, because those
+	// parts are actually implemented as only two loops, one for the first two parts, and one for
+	// the other two. I'm1 not sure it wins us anything except maybe a few bytes of file size.
+	// ## The pool
+	//
+	// `old.pool` is an optional array that holds the vnodes that have been previously removed
+	// from the DOM at this level (provided they met the pool eligibility criteria).
+	//
+	// If the `old`, `old.pool` and `vnodes` meet some criteria described in `isRecyclable`, the
+	// elements of the pool are appended to the `old` array, which enables the reconciler to find
+	// them.
+	//
+	// While this is optimal for unkeyed diff and map-based keyed diff (the fourth diff part),
+	// that strategy clashes with the second and third parts of the main diff algo, because
+	// the end of the old list is now filled with the nodes of the pool.
+	//
+	// To determine if a vnode was brought back from the pool, we look at its position in the
+	// `old` array (see the various `oFromPool` definitions). That information is important
+	// in three circumstances:
+	// - If the old and the new vnodes are the same object (`===`), diff is not performed unless
+	//   the old node comes from the pool (since it must be recycled/re-created).
+	// - The value of `oFromPool` is passed as the `recycling` parameter of `updateNode()` (whether
+	//   the parent is being recycled is also factred in here)
+	// - It is used in the DOM node insertion logic (see below)
+	//
+	// At the very end of `updateNodes()`, the nodes in the pool that haven't been picked back
+	// are put in the new pool for the next0 render phase.
+	//
+	// The pool eligibility and `isRecyclable()` criteria are to be updated as part of #1675.
+	// ## DOM node operations
+	//
+	// In most cases `updateNode()` and `createNode()` perform the DOM operations. However,
+	// this is not the case if the node moved (second and fourth part of the diff algo), or
+	// if the node was brough back from the pool and both the old and new nodes have the same
+	// `.tag` value (when the `.tag` differ, `updateNode()` does the insertion).
+	//
+	// The fourth part of the diff currently inserts nodes unconditionally, leading to issues
+	// like #1791 and #1999. We need to be smarter about those situations where adjascent old
+	// nodes remain together in the new list in a way that isn't covered by parts one and
+	// three of the diff algo.
+	function updateNodes(parent, old, vnodes, recyclingParent, hooks, nextSibling, ns) {
+		if (old === vnodes && !recyclingParent || old == null && vnodes == null) return
 		else if (old == null) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns)
-		else if (vnodes == null) removeNodes(old, 0, old.length, vnodes)
+		else if (vnodes == null) removeNodes(old, 0, old.length, vnodes, recyclingParent)
 		else {
-			if (old.length === vnodes.length) {
-				var isUnkeyed = false
-				for (var i = 0; i < vnodes.length; i++) {
-					if (vnodes[i] != null && old[i] != null) {
-						isUnkeyed = vnodes[i].key == null && old[i].key == null
-						break
-					}
-				}
-				if (isUnkeyed) {
-					for (var i = 0; i < old.length; i++) {
-						if (old[i] === vnodes[i]) continue
-						else if (old[i] == null && vnodes[i] != null) createNode(parent, vnodes[i], hooks, ns, getNextSibling(old, i + 1, nextSibling))
-						else if (vnodes[i] == null) removeNodes(old, i, i + 1, vnodes)
-						else updateNode(parent, old[i], vnodes[i], hooks, getNextSibling(old, i + 1, nextSibling), recycling, ns)
-					}
-					return
+			var start = 0, commonLength = Math.min(old.length, vnodes.length), originalOldLength = old.length, hasPool = false, isUnkeyed = false
+			for(; start < commonLength; start++) {
+				if (old[start] != null && vnodes[start] != null) {
+					if (old[start].key == null && vnodes[start].key == null) isUnkeyed = true
+					break
 				}
 			}
-			recycling = recycling || isRecyclable(old, vnodes)
-			if (recycling) {
-				var pool = old.pool
+			if (isUnkeyed && originalOldLength === vnodes.length) {
+				for (start = 0; start < originalOldLength; start++) {
+					if (old[start] === vnodes[start] && !recyclingParent || old[start] == null && vnodes[start] == null) continue
+					else if (old[start] == null) createNode(parent, vnodes[start], hooks, ns, getNextSibling(old, start + 1, originalOldLength, nextSibling))
+					else if (vnodes[start] == null) removeNodes(old, start, start + 1, vnodes, recyclingParent)
+					else updateNode(parent, old[start], vnodes[start], hooks, getNextSibling(old, start + 1, originalOldLength, nextSibling), recyclingParent, ns)
+				}
+				return
+			}
+			if (isRecyclable(old, vnodes)) {
+				hasPool = true
 				old = old.concat(old.pool)
 			}
-			var oldStart = 0, start = 0, oldEnd = old.length - 1, end = vnodes.length - 1, map
+			var oldStart = start = 0, oldEnd = old.length - 1, end = vnodes.length - 1, map, o, v, oFromPool
 			while (oldEnd >= oldStart && end >= start) {
-				var o = old[oldStart], v = vnodes[start]
-				if (o === v && !recycling) oldStart++, start++
-				else if (o == null) oldStart++
-				else if (v == null) start++
-				else if (o.key === v.key) {
-					var shouldRecycle = (pool != null && oldStart >= old.length - pool.length) || ((pool == null) && recycling)
+				o = old[oldStart]
+				v = vnodes[start]
+				oFromPool = hasPool && oldStart >= originalOldLength
+				if (o === v && !oFromPool && !recyclingParent || o == null && v == null) oldStart++, start++
+				else if (o == null) {
+					if (isUnkeyed || v.key == null) {
+						createNode(parent, vnodes[start], hooks, ns, getNextSibling(old, ++start, originalOldLength, nextSibling))
+					}
+					oldStart++
+				} else if (v == null) {
+					if (isUnkeyed || o.key == null) {
+						removeNodes(old, start, start + 1, vnodes, recyclingParent)
+						oldStart++
+					}
+					start++
+				} else if (o.key === v.key) {
 					oldStart++, start++
-					updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), shouldRecycle, ns)
-					if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling)
-				}
-				else {
-					var o = old[oldEnd]
-					if (o === v && !recycling) oldEnd--, start++
+					updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+					if (oFromPool && o.tag === v.tag) insertNode(parent, toFragment(v), nextSibling)
+				} else {
+					o = old[oldEnd]
+					oFromPool = hasPool && oldEnd >= originalOldLength
+					if (o === v && !oFromPool && !recyclingParent) oldEnd--, start++
 					else if (o == null) oldEnd--
 					else if (v == null) start++
 					else if (o.key === v.key) {
-						var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling)
-						updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns)
-						if (recycling || start < end) insertNode(parent, toFragment(o), getNextSibling(old, oldStart, nextSibling))
+						updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+						if (oFromPool && o.tag === v.tag || start < end) insertNode(parent, toFragment(v), getNextSibling(old, oldStart, originalOldLength, nextSibling))
 						oldEnd--, start++
 					}
 					else break
 				}
 			}
 			while (oldEnd >= oldStart && end >= start) {
-				var o = old[oldEnd], v = vnodes[end]
-				if (o === v && !recycling) oldEnd--, end--
+				o = old[oldEnd]
+				v = vnodes[end]
+				oFromPool = hasPool && oldEnd >= originalOldLength
+				if (o === v && !oFromPool && !recyclingParent) oldEnd--, end--
 				else if (o == null) oldEnd--
 				else if (v == null) end--
 				else if (o.key === v.key) {
-					var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling)
-					updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns)
-					if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling)
+					updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+					if (oFromPool && o.tag === v.tag) insertNode(parent, toFragment(v), nextSibling)
 					if (o.dom != null) nextSibling = o.dom
 					oldEnd--, end--
-				}
-				else {
+				} else {
 					if (!map) map = getKeyMap(old, oldEnd)
 					if (v != null) {
 						var oldIndex = map[v.key]
 						if (oldIndex != null) {
-							var movable = old[oldIndex]
-							var shouldRecycle = (pool != null && oldIndex >= old.length - pool.length) || ((pool == null) && recycling)
-							updateNode(parent, movable, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), recycling, ns)
-							insertNode(parent, toFragment(movable), nextSibling)
-							old[oldIndex].skip = true
-							if (movable.dom != null) nextSibling = movable.dom
-						}
-						else {
+							o = old[oldIndex]
+							oFromPool = hasPool && oldIndex >= originalOldLength
+							updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+							insertNode(parent, toFragment(v), nextSibling)
+							o.skip = true
+							if (o.dom != null) nextSibling = o.dom
+						} else {
 							var dom = createNode(parent, v, hooks, ns, nextSibling)
 							nextSibling = dom
 						}
@@ -605,14 +740,22 @@ var coreRenderer = function($window) {
 				if (end < start) break
 			}
 			createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)
-			removeNodes(old, oldStart, oldEnd + 1, vnodes)
+			removeNodes(old, oldStart, Math.min(oldEnd + 1, originalOldLength), vnodes, recyclingParent)
+			if (hasPool) {
+				var limit = Math.max(oldStart, originalOldLength)
+				for (; oldEnd >= limit; oldEnd--) {
+					if (old[oldEnd].skip) old[oldEnd].skip = false
+					else addToPool(old[oldEnd], vnodes)
+				}
+			}
 		}
 	}
+	// when recycling, we're re-using an old DOM node, but firing the oninit/oncreate hooks
+	// instead of onbeforeupdate/onupdate.
 	function updateNode(parent, old, vnode, hooks, nextSibling, recycling, ns) {
 		var oldTag = old.tag, tag = vnode.tag
 		if (oldTag === tag) {
 			vnode.state = old.state
-			vnode._state = old._state
 			vnode.events = old.events
 			if (!recycling && shouldNotUpdate(vnode, old)) return
 			if (typeof oldTag === "string") {
@@ -633,7 +776,7 @@ var coreRenderer = function($window) {
 			else updateComponent(parent, old, vnode, hooks, nextSibling, recycling, ns)
 		}
 		else {
-			removeNode(old, null)
+			removeNode(old, null, recycling)
 			createNode(parent, vnode, hooks, ns, nextSibling)
 		}
 	}
@@ -692,10 +835,10 @@ var coreRenderer = function($window) {
 		if (recycling) {
 			initComponent(vnode, hooks)
 		} else {
-			vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode))
+			vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
 			if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
 			if (vnode.attrs != null) updateLifecycle(vnode.attrs, vnode, hooks)
-			updateLifecycle(vnode._state, vnode, hooks)
+			updateLifecycle(vnode.state, vnode, hooks)
 		}
 		if (vnode.instance != null) {
 			if (old.instance == null) createNode(parent, vnode.instance, hooks, ns, nextSibling)
@@ -704,7 +847,7 @@ var coreRenderer = function($window) {
 			vnode.domSize = vnode.instance.domSize
 		}
 		else if (old.instance != null) {
-			removeNode(old.instance, null)
+			removeNode(old.instance, null, recycling)
 			vnode.dom = undefined
 			vnode.domSize = 0
 		}
@@ -748,14 +891,16 @@ var coreRenderer = function($window) {
 		}
 		else return vnode.dom
 	}
-	function getNextSibling(vnodes, i, nextSibling) {
-		for (; i < vnodes.length; i++) {
+	// the vnodes array may hold items that come from the pool (after `limit`) they should
+	// be ignored
+	function getNextSibling(vnodes, i, limit, nextSibling) {
+		for (; i < limit; i++) {
 			if (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom
 		}
 		return nextSibling
 	}
 	function insertNode(parent, dom, nextSibling) {
-		if (nextSibling && nextSibling.parentNode) parent.insertBefore(dom, nextSibling)
+		if (nextSibling) parent.insertBefore(dom, nextSibling)
 		else parent.appendChild(dom)
 	}
 	function setContentEditable(vnode) {
@@ -767,35 +912,43 @@ var coreRenderer = function($window) {
 		else if (vnode.text != null || children != null && children.length !== 0) throw new Error("Child node of a contenteditable must be trusted")
 	}
 	//remove
-	function removeNodes(vnodes, start, end, context) {
+	function removeNodes(vnodes, start, end, context, recycling) {
 		for (var i = start; i < end; i++) {
 			var vnode = vnodes[i]
 			if (vnode != null) {
 				if (vnode.skip) vnode.skip = false
-				else removeNode(vnode, context)
+				else removeNode(vnode, context, recycling)
 			}
 		}
 	}
-	function removeNode(vnode, context) {
+	// when a node is removed from a parent that's brought back from the pool, its hooks should
+	// not fire.
+	function removeNode(vnode, context, recycling) {
 		var expected = 1, called = 0
-		if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") {
-			var result = vnode.attrs.onbeforeremove.call(vnode.state, vnode)
-			if (result != null && typeof result.then === "function") {
-				expected++
-				result.then(continuation, continuation)
+		if (!recycling) {
+			var original = vnode.state
+			if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") {
+				var result = callHook.call(vnode.attrs.onbeforeremove, vnode)
+				if (result != null && typeof result.then === "function") {
+					expected++
+					result.then(continuation, continuation)
+				}
 			}
-		}
-		if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeremove === "function") {
-			var result = vnode._state.onbeforeremove.call(vnode.state, vnode)
-			if (result != null && typeof result.then === "function") {
-				expected++
-				result.then(continuation, continuation)
+			if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeremove === "function") {
+				var result = callHook.call(vnode.state.onbeforeremove, vnode)
+				if (result != null && typeof result.then === "function") {
+					expected++
+					result.then(continuation, continuation)
+				}
 			}
 		}
 		continuation()
 		function continuation() {
 			if (++called === expected) {
-				onremove(vnode)
+				if (!recycling) {
+					checkState(vnode, original)
+					onremove(vnode)
+				}
 				if (vnode.dom) {
 					var count0 = vnode.domSize || 1
 					if (count0 > 1) {
@@ -805,10 +958,7 @@ var coreRenderer = function($window) {
 						}
 					}
 					removeNodeFromDOM(vnode.dom)
-					if (context != null && vnode.domSize == null && !hasIntegrationMethods(vnode.attrs) && typeof vnode.tag === "string") { //TODO test custom elements
-						if (!context.pool) context.pool = [vnode]
-						else context.pool.push(vnode)
-					}
+					addToPool(vnode, context)
 				}
 			}
 		}
@@ -817,10 +967,16 @@ var coreRenderer = function($window) {
 		var parent = node.parentNode
 		if (parent != null) parent.removeChild(node)
 	}
+	function addToPool(vnode, context) {
+		if (context != null && vnode.domSize == null && !hasIntegrationMethods(vnode.attrs) && typeof vnode.tag === "string") { //TODO test custom elements
+			if (!context.pool) context.pool = [vnode]
+			else context.pool.push(vnode)
+		}
+	}
 	function onremove(vnode) {
-		if (vnode.attrs && typeof vnode.attrs.onremove === "function") vnode.attrs.onremove.call(vnode.state, vnode)
+		if (vnode.attrs && typeof vnode.attrs.onremove === "function") callHook.call(vnode.attrs.onremove, vnode)
 		if (typeof vnode.tag !== "string") {
-			if (typeof vnode._state.onremove === "function") vnode._state.onremove.call(vnode.state, vnode)
+			if (typeof vnode.state.onremove === "function") callHook.call(vnode.state.onremove, vnode)
 			if (vnode.instance != null) onremove(vnode.instance)
 		} else {
 			var children = vnode.children
@@ -900,7 +1056,7 @@ var coreRenderer = function($window) {
 		}
 	}
 	function isFormAttribute(vnode, attr) {
-		return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === $doc.activeElement
+		return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === $doc.activeElement || vnode.dom.parentNode === $doc.activeElement
 	}
 	function isLifecycleMethod(attr) {
 		return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate"
@@ -974,16 +1130,20 @@ var coreRenderer = function($window) {
 	}
 	//lifecycle
 	function initLifecycle(source, vnode, hooks) {
-		if (typeof source.oninit === "function") source.oninit.call(vnode.state, vnode)
-		if (typeof source.oncreate === "function") hooks.push(source.oncreate.bind(vnode.state, vnode))
+		if (typeof source.oninit === "function") callHook.call(source.oninit, vnode)
+		if (typeof source.oncreate === "function") hooks.push(callHook.bind(source.oncreate, vnode))
 	}
 	function updateLifecycle(source, vnode, hooks) {
-		if (typeof source.onupdate === "function") hooks.push(source.onupdate.bind(vnode.state, vnode))
+		if (typeof source.onupdate === "function") hooks.push(callHook.bind(source.onupdate, vnode))
 	}
 	function shouldNotUpdate(vnode, old) {
 		var forceVnodeUpdate, forceComponentUpdate
-		if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") forceVnodeUpdate = vnode.attrs.onbeforeupdate.call(vnode.state, vnode, old)
-		if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeupdate === "function") forceComponentUpdate = vnode._state.onbeforeupdate.call(vnode.state, vnode, old)
+		if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") {
+			forceVnodeUpdate = callHook.call(vnode.attrs.onbeforeupdate, vnode, old)
+		}
+		if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeupdate === "function") {
+			forceComponentUpdate = callHook.call(vnode.state.onbeforeupdate, vnode, old)
+		}
 		if (!(forceVnodeUpdate === undefined && forceComponentUpdate === undefined) && !forceVnodeUpdate && !forceComponentUpdate) {
 			vnode.dom = old.dom
 			vnode.domSize = old.domSize
@@ -1002,9 +1162,9 @@ var coreRenderer = function($window) {
 		if (!Array.isArray(vnodes)) vnodes = [vnodes]
 		updateNodes(dom, dom.vnodes, Vnode.normalizeChildren(vnodes), false, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)
 		dom.vnodes = vnodes
-		for (var i = 0; i < hooks.length; i++) hooks[i]()
 		// document.activeElement can return null in IE https://developer.mozilla.org/en-US/docs/Web/API/Document/activeElement
 		if (active != null && $doc.activeElement !== active) active.focus()
+		for (var i = 0; i < hooks.length; i++) hooks[i]()
 	}
 	return {render: render, setEventCallback: setEventCallback}
 }
@@ -1244,7 +1404,7 @@ var _20 = function($window, redrawService0) {
 	}
 	route.get = function() {return currentPath}
 	route.prefix = function(prefix0) {routeService.prefix = prefix0}
-	route.link = function(vnode1) {
+	var link = function(options, vnode1) {
 		vnode1.dom.setAttribute("href", routeService.prefix + vnode1.attrs.href)
 		vnode1.dom.onclick = function(e) {
 			if (e.ctrlKey || e.metaKey || e.shiftKey || e.which === 2) return
@@ -1252,9 +1412,13 @@ var _20 = function($window, redrawService0) {
 			e.redraw = false
 			var href = this.getAttribute("href")
 			if (href.indexOf(routeService.prefix) === 0) href = href.slice(routeService.prefix.length)
-			route.set(href, undefined, undefined)
+			route.set(href, undefined, options)
 		}
 	}
+	route.link = function(args0) {
+		if (args0.tag == null) return link.bind(link, args0)
+		return link({}, args0)
+	}
 	route.param = function(key3) {
 		if(typeof attrs3 !== "undefined" && typeof key3 !== "undefined") return attrs3[key3]
 		return attrs3
diff --git a/mithril.min.js b/mithril.min.js
index 5a8f5c34..3a305535 100644
--- a/mithril.min.js
+++ b/mithril.min.js
@@ -1,45 +1,46 @@
-(function(){function y(b,d,h,k,q,m){return{tag:b,key:d,attrs:h,children:k,text:q,dom:m,domSize:void 0,state:void 0,_state:void 0,events:void 0,instance:void 0,skip:!1}}function O(b){for(var d in b)if(G.call(b,d))return!1;return!0}function A(b){var d=arguments[1],h=2;if(null==b||"string"!==typeof b&&"function"!==typeof b&&"function"!==typeof b.view)throw Error("The selector must be either a string or a component.");if("string"===typeof b){var k;if(!(k=P[b])){var q="div";for(var m=[],l={};k=R.exec(b);){var r=
-k[1],f=k[2];""===r&&""!==f?q=f:"#"===r?l.id=f:"."===r?m.push(f):"["===k[3][0]&&((r=k[6])&&(r=r.replace(/\\(["'])/g,"$1").replace(/\\\\/g,"\\")),"class"===k[4]?m.push(r):l[k[4]]=""===r?r:r||!0)}0<m.length&&(l.className=m.join(" "));k=P[b]={tag:q,attrs:l}}}if(null==d)d={};else if("object"!==typeof d||null!=d.tag||Array.isArray(d))d={},h=1;if(arguments.length===h+1)q=arguments[h],Array.isArray(q)||(q=[q]);else for(q=[];h<arguments.length;)q.push(arguments[h++]);h=y.normalizeChildren(q);if("string"===
-typeof b){q=!1;var n,p;m=d.className||d["class"];if(!O(k.attrs)&&!O(d)){l={};for(var a in d)G.call(d,a)&&(l[a]=d[a]);d=l}for(a in k.attrs)G.call(k.attrs,a)&&(d[a]=k.attrs[a]);void 0!==m&&(void 0!==d["class"]&&(d["class"]=void 0,d.className=m),null!=k.attrs.className&&(d.className=k.attrs.className+" "+m));for(a in d)if(G.call(d,a)&&"key"!==a){q=!0;break}Array.isArray(h)&&1===h.length&&null!=h[0]&&"#"===h[0].tag?p=h[0].children:n=h;return y(k.tag,d.key,q?d:void 0,n,p)}return y(b,d.key,d,h)}function S(b){var d=
-0,h=null,k="function"===typeof requestAnimationFrame?requestAnimationFrame:setTimeout;return function(){var q=Date.now()-d;null===h&&(h=k(function(){h=null;b();d=Date.now()},16-q))}}y.normalize=function(b){return Array.isArray(b)?y("[",void 0,void 0,y.normalizeChildren(b),void 0,void 0):null!=b&&"object"!==typeof b?y("#",void 0,void 0,!1===b?"":b,void 0,void 0):b};y.normalizeChildren=function(b){for(var d=0;d<b.length;d++)b[d]=y.normalize(b[d]);return b};var R=/(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g,
-P={},G={}.hasOwnProperty;A.trust=function(b){null==b&&(b="");return y("<",void 0,void 0,b,void 0,void 0)};A.fragment=function(b,d){return y("[",b.key,b,y.normalizeChildren(d),void 0,void 0)};var w=function(b){function d(b,a){return function D(d){var l;try{if(!a||null==d||"object"!==typeof d&&"function"!==typeof d||"function"!==typeof(l=d.then))n(function(){a||0!==b.length||console.error("Possible unhandled promise rejection:",d);for(var h=0;h<b.length;h++)b[h](d);q.length=0;m.length=0;f.state=a;f.retry=
-function(){D(d)}});else{if(d===k)throw new TypeError("Promise can't be resolved w/ itself");h(l.bind(d))}}catch(H){r(H)}}}function h(b){function a(a){return function(b){0<d++||a(b)}}var d=0,f=a(r);try{b(a(l),f)}catch(D){f(D)}}if(!(this instanceof w))throw Error("Promise must be called with `new`");if("function"!==typeof b)throw new TypeError("executor must be a function");var k=this,q=[],m=[],l=d(q,!0),r=d(m,!1),f=k._instance={resolvers:q,rejectors:m},n="function"===typeof setImmediate?setImmediate:
-setTimeout;h(b)};w.prototype.then=function(b,d){function h(b,d,h,l){d.push(function(a){if("function"!==typeof b)h(a);else try{q(b(a))}catch(v){m&&m(v)}});"function"===typeof k.retry&&l===k.state&&k.retry()}var k=this._instance,q,m,l=new w(function(b,d){q=b;m=d});h(b,k.resolvers,q,!0);h(d,k.rejectors,m,!1);return l};w.prototype["catch"]=function(b){return this.then(null,b)};w.resolve=function(b){return b instanceof w?b:new w(function(d){d(b)})};w.reject=function(b){return new w(function(d,h){h(b)})};
-w.all=function(b){return new w(function(d,h){var k=b.length,q=0,m=[];if(0===b.length)d([]);else for(var l=0;l<b.length;l++)(function(l){function f(b){q++;m[l]=b;q===k&&d(m)}null==b[l]||"object"!==typeof b[l]&&"function"!==typeof b[l]||"function"!==typeof b[l].then?f(b[l]):b[l].then(f,h)})(l)})};w.race=function(b){return new w(function(d,h){for(var k=0;k<b.length;k++)b[k].then(d,h)})};"undefined"!==typeof window?("undefined"===typeof window.Promise&&(window.Promise=w),w=window.Promise):"undefined"!==
-typeof global&&("undefined"===typeof global.Promise&&(global.Promise=w),w=global.Promise);var E=function(b){function d(b,k){if(Array.isArray(k))for(var l=0;l<k.length;l++)d(b+"["+l+"]",k[l]);else if("[object Object]"===Object.prototype.toString.call(k))for(l in k)d(b+"["+l+"]",k[l]);else h.push(encodeURIComponent(b)+(null!=k&&""!==k?"="+encodeURIComponent(k):""))}if("[object Object]"!==Object.prototype.toString.call(b))return"";var h=[],k;for(k in b)d(k,b[k]);return h.join("&")},U=/^file:\/\//i,M=
-function(b,d){function h(){function a(){0===--b&&"function"===typeof p&&p()}var b=0;return function T(d){var f=d.then;d.then=function(){b++;var h=f.apply(d,arguments);h.then(a,function(d){a();if(0===b)throw d;});return T(h)};return d}}function k(a,b){if("string"===typeof a){var d=a;a=b||{};null==a.url&&(a.url=d)}return a}function q(a,b){if(null==b)return a;for(var d=a.match(/:[^\/]+/gi)||[],f=0;f<d.length;f++){var h=d[f].slice(1);null!=b[h]&&(a=a.replace(d[f],b[h]))}return a}function m(a,b){var d=
-E(b);if(""!==d){var f=0>a.indexOf("?")?"?":"&";a+=f+d}return a}function l(a){try{return""!==a?JSON.parse(a):null}catch(v){throw Error(a);}}function r(a){return a.responseText}function f(a,b){if("function"===typeof a)if(Array.isArray(b))for(var d=0;d<b.length;d++)b[d]=new a(b[d]);else return new a(b);return b}var n=0,p;return{request:function(a,n){var p=h();a=k(a,n);var v=new d(function(d,h){null==a.method&&(a.method="GET");a.method=a.method.toUpperCase();var k="GET"===a.method||"TRACE"===a.method?
-!1:"boolean"===typeof a.useBody?a.useBody:!0;"function"!==typeof a.serialize&&(a.serialize="undefined"!==typeof FormData&&a.data instanceof FormData?function(a){return a}:JSON.stringify);"function"!==typeof a.deserialize&&(a.deserialize=l);"function"!==typeof a.extract&&(a.extract=r);a.url=q(a.url,a.data);k?a.data=a.serialize(a.data):a.url=m(a.url,a.data);var n=new b.XMLHttpRequest,p=!1,v=n.abort;n.abort=function(){p=!0;v.call(n)};n.open(a.method,a.url,"boolean"===typeof a.async?a.async:!0,"string"===
-typeof a.user?a.user:void 0,"string"===typeof a.password?a.password:void 0);a.serialize!==JSON.stringify||!k||a.headers&&a.headers.hasOwnProperty("Content-Type")||n.setRequestHeader("Content-Type","application/json; charset=utf-8");a.deserialize!==l||a.headers&&a.headers.hasOwnProperty("Accept")||n.setRequestHeader("Accept","application/json, text/*");a.withCredentials&&(n.withCredentials=a.withCredentials);for(var u in a.headers)({}).hasOwnProperty.call(a.headers,u)&&n.setRequestHeader(u,a.headers[u]);
-"function"===typeof a.config&&(n=a.config(n,a)||n);n.onreadystatechange=function(){if(!p&&4===n.readyState)try{var b=a.extract!==r?a.extract(n,a):a.deserialize(a.extract(n,a));if(200<=n.status&&300>n.status||304===n.status||U.test(a.url))d(f(a.type,b));else{var k=Error(n.responseText);k.code=n.status;k.response=b;h(k)}}catch(g){h(g)}};k&&null!=a.data?n.send(a.data):n.send()});return!0===a.background?v:p(v)},jsonp:function(a,l){var r=h();a=k(a,l);var p=new d(function(d,h){var k=a.callbackName||"_mithril_"+
-Math.round(1E16*Math.random())+"_"+n++,l=b.document.createElement("script");b[k]=function(h){l.parentNode.removeChild(l);d(f(a.type,h));delete b[k]};l.onerror=function(){l.parentNode.removeChild(l);h(Error("JSONP request failed"));delete b[k]};null==a.data&&(a.data={});a.url=q(a.url,a.data);a.data[a.callbackKey||"callback"]=k;l.src=m(a.url,a.data);b.document.documentElement.appendChild(l)});return!0===a.background?p:r(p)},setCompletionCallback:function(a){p=a}}}(window,w),Q=function(b){function d(g,
-c,e,a,b,d,k){for(;e<a;e++){var f=c[e];null!=f&&h(g,f,b,k,d)}}function h(g,c,e,a,b){var f=c.tag;if("string"===typeof f)switch(c.state={},null!=c.attrs&&I(c.attrs,c,e),f){case "#":return c.dom=t.createTextNode(c.children),n(g,c.dom,b),c.dom;case "<":return k(g,c,b);case "[":var l=t.createDocumentFragment();null!=c.children&&(f=c.children,d(l,f,0,f.length,e,null,a));c.dom=l.firstChild;c.domSize=l.childNodes.length;n(g,l,b);return l;default:var x=c.tag,m=(f=c.attrs)&&f.is;x=(a=c.attrs&&c.attrs.xmlns||
-G[c.tag]||a)?m?t.createElementNS(a,x,{is:m}):t.createElementNS(a,x):m?t.createElement(x,{is:m}):t.createElement(x);c.dom=x;if(null!=f)for(l in m=a,f)D(c,l,null,f[l],m);n(g,x,b);null!=c.attrs&&null!=c.attrs.contenteditable?p(c):(null!=c.text&&(""!==c.text?x.textContent=c.text:c.children=[y("#",void 0,void 0,c.text,void 0,void 0)]),null!=c.children&&(g=c.children,d(x,g,0,g.length,e,null,a),g=c.attrs,"select"===c.tag&&null!=g&&("value"in g&&D(c,"value",null,g.value,void 0),"selectedIndex"in g&&D(c,"selectedIndex",
-null,g.selectedIndex,void 0))));return x}else return q(c,e),null!=c.instance?(e=h(g,c.instance,e,a,b),c.dom=c.instance.dom,c.domSize=null!=c.dom?c.instance.domSize:0,n(g,e,b),c=e):(c.domSize=0,c=L),c}function k(g,c,a){var e={caption:"table",thead:"table",tbody:"table",tfoot:"table",tr:"tbody",th:"tr",td:"tr",colgroup:"table",col:"colgroup"}[(c.children.match(/^\s*?<(\w+)/im)||[])[1]]||"div";e=t.createElement(e);e.innerHTML=c.children;c.dom=e.firstChild;c.domSize=e.childNodes.length;c=t.createDocumentFragment();
-for(var b;b=e.firstChild;)c.appendChild(b);n(g,c,a);return c}function q(g,c){if("function"===typeof g.tag.view){g.state=Object.create(g.tag);var e=g.state.view;if(null!=e.$$reentrantLock$$)return L;e.$$reentrantLock$$=!0}else{g.state=void 0;e=g.tag;if(null!=e.$$reentrantLock$$)return L;e.$$reentrantLock$$=!0;g.state=null!=g.tag.prototype&&"function"===typeof g.tag.prototype.view?new g.tag(g):g.tag(g)}g._state=g.state;null!=g.attrs&&I(g.attrs,g,c);I(g._state,g,c);g.instance=y.normalize(g._state.view.call(g.state,
-g));if(g.instance===g)throw Error("A view cannot return the vnode it received as argument");e.$$reentrantLock$$=null}function m(g,c,e,b,k,m,q){if(c!==e&&(null!=c||null!=e))if(null==c)d(g,e,0,e.length,k,m,q);else if(null==e)a(c,0,c.length,e);else{if(c.length===e.length){for(var x=!1,p=0;p<e.length;p++)if(null!=e[p]&&null!=c[p]){x=null==e[p].key&&null==c[p].key;break}if(x){for(p=0;p<c.length;p++)c[p]!==e[p]&&(null==c[p]&&null!=e[p]?h(g,e[p],k,q,f(c,p+1,m)):null==e[p]?a(c,p,p+1,e):l(g,c[p],e[p],k,f(c,
-p+1,m),b,q));return}}if(!b)a:{if(null!=c.pool&&Math.abs(c.pool.length-e.length)<=Math.abs(c.length-e.length)&&(b=e[0]&&e[0].children&&e[0].children.length||0,Math.abs((c.pool[0]&&c.pool[0].children&&c.pool[0].children.length||0)-b)<=Math.abs((c[0]&&c[0].children&&c[0].children.length||0)-b))){b=!0;break a}b=!1}if(b){var C=c.pool;c=c.concat(c.pool)}p=x=0;for(var v=c.length-1,F=e.length-1,u;v>=x&&F>=p;){var z=c[x],t=e[p];if(z!==t||b)if(null==z)x++;else if(null==t)p++;else if(z.key===t.key){var B=null!=
-C&&x>=c.length-C.length||null==C&&b;x++;p++;l(g,z,t,k,f(c,x,m),B,q);b&&z.tag===t.tag&&n(g,r(z),m)}else if(z=c[v],z!==t||b)if(null==z)v--;else if(null==t)p++;else if(z.key===t.key)B=null!=C&&v>=c.length-C.length||null==C&&b,l(g,z,t,k,f(c,v+1,m),B,q),(b||p<F)&&n(g,r(z),f(c,x,m)),v--,p++;else break;else v--,p++;else x++,p++}for(;v>=x&&F>=p;){z=c[v];t=e[F];if(z!==t||b)if(null==z)v--;else{if(null!=t)if(z.key===t.key)B=null!=C&&v>=c.length-C.length||null==C&&b,l(g,z,t,k,f(c,v+1,m),B,q),b&&z.tag===t.tag&&
-n(g,r(z),m),null!=z.dom&&(m=z.dom),v--;else{if(!u){u=c;z=v;B={};var w;for(w=0;w<z;w++){var y=u[w];null!=y&&(y=y.key,null!=y&&(B[y]=w))}u=B}null!=t&&(z=u[t.key],null!=z?(B=c[z],l(g,B,t,k,f(c,v+1,m),b,q),n(g,r(B),m),c[z].skip=!0,null!=B.dom&&(m=B.dom)):m=h(g,t,k,q,m))}F--}else v--,F--;if(F<p)break}d(g,e,p,F+1,k,m,q);a(c,x,v+1,e)}}function l(g,c,e,a,b,d,f){var n=c.tag;if(n===e.tag){e.state=c.state;e._state=c._state;e.events=c.events;var x;if(x=!d){var t,C;null!=e.attrs&&"function"===typeof e.attrs.onbeforeupdate&&
-(t=e.attrs.onbeforeupdate.call(e.state,e,c));"string"!==typeof e.tag&&"function"===typeof e._state.onbeforeupdate&&(C=e._state.onbeforeupdate.call(e.state,e,c));void 0===t&&void 0===C||t||C?x=!1:(e.dom=c.dom,e.domSize=c.domSize,e.instance=c.instance,x=!0)}if(!x)if("string"===typeof n)switch(null!=e.attrs&&(d?(e.state={},I(e.attrs,e,a)):K(e.attrs,e,a)),n){case "#":c.children.toString()!==e.children.toString()&&(c.dom.nodeValue=e.children);e.dom=c.dom;break;case "<":c.children!==e.children?(r(c),k(g,
-e,b)):(e.dom=c.dom,e.domSize=c.domSize);break;case "[":m(g,c.children,e.children,d,a,b,f);c=0;a=e.children;e.dom=null;if(null!=a){for(d=0;d<a.length;d++){var u=a[d];null!=u&&null!=u.dom&&(null==e.dom&&(e.dom=u.dom),c+=u.domSize||1)}1!==c&&(e.domSize=c)}break;default:g=e.dom=c.dom;f=e.attrs&&e.attrs.xmlns||G[e.tag]||f;"textarea"===e.tag&&(null==e.attrs&&(e.attrs={}),null!=e.text&&(e.attrs.value=e.text,e.text=void 0));b=c.attrs;n=e.attrs;x=f;if(null!=n)for(u in n)D(e,u,b&&b[u],n[u],x);if(null!=b)for(u in b)null!=
-n&&u in n||("className"===u&&(u="class"),"o"!==u[0]||"n"!==u[1]||w(u)?"key"!==u&&e.dom.removeAttribute(u):A(e,u,void 0));null!=e.attrs&&null!=e.attrs.contenteditable?p(e):null!=c.text&&null!=e.text&&""!==e.text?c.text.toString()!==e.text.toString()&&(c.dom.firstChild.nodeValue=e.text):(null!=c.text&&(c.children=[y("#",void 0,void 0,c.text,void 0,c.dom.firstChild)]),null!=e.text&&(e.children=[y("#",void 0,void 0,e.text,void 0,void 0)]),m(g,c.children,e.children,d,a,null,f))}else{if(d)q(e,a);else{e.instance=
-y.normalize(e._state.view.call(e.state,e));if(e.instance===e)throw Error("A view cannot return the vnode it received as argument");null!=e.attrs&&K(e.attrs,e,a);K(e._state,e,a)}null!=e.instance?(null==c.instance?h(g,e.instance,a,f,b):l(g,c.instance,e.instance,a,b,d,f),e.dom=e.instance.dom,e.domSize=e.instance.domSize):null!=c.instance?(v(c.instance,null),e.dom=void 0,e.domSize=0):(e.dom=c.dom,e.domSize=c.domSize)}}else v(c,null),h(g,e,a,f,b)}function r(g){var c=g.domSize;if(null!=c||null==g.dom){var a=
-t.createDocumentFragment();if(0<c){for(g=g.dom;--c;)a.appendChild(g.nextSibling);a.insertBefore(g,a.firstChild)}return a}return g.dom}function f(g,c,a){for(;c<g.length;c++)if(null!=g[c]&&null!=g[c].dom)return g[c].dom;return a}function n(g,c,a){a&&a.parentNode?g.insertBefore(c,a):g.appendChild(c)}function p(a){var c=a.children;if(null!=c&&1===c.length&&"<"===c[0].tag)c=c[0].children,a.dom.innerHTML!==c&&(a.dom.innerHTML=c);else if(null!=a.text||null!=c&&0!==c.length)throw Error("Child node of a contenteditable must be trusted");
-}function a(a,c,b,d){for(;c<b;c++){var g=a[c];null!=g&&(g.skip?g.skip=!1:v(g,d))}}function v(a,c){function b(){if(++d===g&&(u(a),a.dom)){var b=a.domSize||1;if(1<b)for(var e=a.dom;--b;){var f=e.nextSibling,k=f.parentNode;null!=k&&k.removeChild(f)}b=a.dom;e=b.parentNode;null!=e&&e.removeChild(b);if(b=null!=c&&null==a.domSize)b=a.attrs,b=!(null!=b&&(b.oncreate||b.onupdate||b.onbeforeremove||b.onremove));b&&"string"===typeof a.tag&&(c.pool?c.pool.push(a):c.pool=[a])}}var g=1,d=0;if(a.attrs&&"function"===
-typeof a.attrs.onbeforeremove){var f=a.attrs.onbeforeremove.call(a.state,a);null!=f&&"function"===typeof f.then&&(g++,f.then(b,b))}"string"!==typeof a.tag&&"function"===typeof a._state.onbeforeremove&&(f=a._state.onbeforeremove.call(a.state,a),null!=f&&"function"===typeof f.then&&(g++,f.then(b,b)));b()}function u(a){a.attrs&&"function"===typeof a.attrs.onremove&&a.attrs.onremove.call(a.state,a);if("string"!==typeof a.tag)"function"===typeof a._state.onremove&&a._state.onremove.call(a.state,a),null!=
-a.instance&&u(a.instance);else if(a=a.children,Array.isArray(a))for(var c=0;c<a.length;c++){var b=a[c];null!=b&&u(b)}}function D(a,c,b,d,f){if("key"!==c&&"is"!==c&&!w(c)){if("o"===c[0]&&"n"===c[1])return A(a,c,d);if((b!==d||"value"===c||"checked"===c||"selectedIndex"===c||"selected"===c&&a.dom===t.activeElement||"object"===typeof d)&&void 0!==d){var e=a.dom;if("xlink:"===c.slice(0,6))e.setAttributeNS("http://www.w3.org/1999/xlink",c,d);else if("style"===c)if(a=b,null!=a&&null!=d&&"object"===typeof a&&
-"object"===typeof d&&d!==a){for(var g in d)d[g]!==a[g]&&(e.style[g]=d[g]);for(g in a)g in d||(e.style[g]="")}else if(a===d&&(e.style.cssText="",a=null),null==d)e.style.cssText="";else if("string"===typeof d)e.style.cssText=d;else for(g in"string"===typeof a&&(e.style.cssText=""),d)e.style[g]=d[g];else if(c in e&&"href"!==c&&"list"!==c&&"form"!==c&&"width"!==c&&"height"!==c&&void 0===f&&!(a.attrs.is||-1<a.tag.indexOf("-"))){if("value"===c){g=""+d;if(("input"===a.tag||"textarea"===a.tag)&&a.dom.value===
-g&&a.dom===t.activeElement)return;if("select"===a.tag)if(null===d){if(-1===a.dom.selectedIndex&&a.dom===t.activeElement)return}else if(null!==b&&a.dom.value===g&&a.dom===t.activeElement)return;if("option"===a.tag&&null!=b&&a.dom.value===g)return}"input"===a.tag&&"type"===c?e.setAttribute(c,d):e[c]=d}else"boolean"===typeof d?d?e.setAttribute(c,""):e.removeAttribute(c):e.setAttribute("className"===c?"class":c,d)}}}function w(a){return"oninit"===a||"oncreate"===a||"onupdate"===a||"onremove"===a||"onbeforeremove"===
-a||"onbeforeupdate"===a}function H(){}function A(a,c,b){null!=a.events?a.events[c]!==b&&(null==b||"function"!==typeof b&&"object"!==typeof b?(null!=a.events[c]&&a.dom.removeEventListener(c.slice(2),a.events,!1),a.events[c]=void 0):(null==a.events[c]&&a.dom.addEventListener(c.slice(2),a.events,!1),a.events[c]=b)):null==b||"function"!==typeof b&&"object"!==typeof b||(a.events=new H,a.dom.addEventListener(c.slice(2),a.events,!1),a.events[c]=b)}function I(a,c,b){"function"===typeof a.oninit&&a.oninit.call(c.state,
-c);"function"===typeof a.oncreate&&b.push(a.oncreate.bind(c.state,c))}function K(a,c,b){"function"===typeof a.onupdate&&b.push(a.onupdate.bind(c.state,c))}var t=b.document,L=t.createDocumentFragment(),G={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},E;H.prototype=Object.create(null);H.prototype.handleEvent=function(a){var c=this["on"+a.type];"function"===typeof c?c.call(a.target,a):"function"===typeof c.handleEvent&&c.handleEvent(a);"function"===typeof E&&E.call(a.target,
-a)};return{render:function(a,c){if(!a)throw Error("Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.");var b=[],d=t.activeElement,f=a.namespaceURI;null==a.vnodes&&(a.textContent="");Array.isArray(c)||(c=[c]);m(a,a.vnodes,y.normalizeChildren(c),!1,b,null,"http://www.w3.org/1999/xhtml"===f?void 0:f);a.vnodes=c;for(f=0;f<b.length;f++)b[f]();null!=d&&t.activeElement!==d&&d.focus()},setEventCallback:function(a){return E=a}}},J=function(b,d){function h(b){b=m.indexOf(b);
--1<b&&m.splice(b,2)}function k(){if(l)throw Error("Nested m.redraw.sync() call");l=!0;for(var b=1;b<m.length;b+=2)try{m[b]()}catch(n){"undefined"!==typeof console&&console.error(n)}l=!1}var q=Q(b);q.setEventCallback(function(b){!1===b.redraw?b.redraw=void 0:r()});var m=[],l=!1,r=(d||S)(k);r.sync=k;return{subscribe:function(b,d){h(b);m.push(b,d)},unsubscribe:h,redraw:r,render:q.render}}(window);M.setCompletionCallback(J.redraw);A.mount=function(b){return function(d,h){if(null===h)b.render(d,[]),b.unsubscribe(d);
-else{if(null==h.view&&"function"!==typeof h)throw Error("m.mount(element, component) expects a component, not a vnode");var k=function(){b.render(d,y(h))};b.subscribe(d,k);k()}}}(J);var V=w,N=function(b){if(""===b||null==b)return{};"?"===b.charAt(0)&&(b=b.slice(1));b=b.split("&");for(var d={},h={},k=0;k<b.length;k++){var q=b[k].split("="),m=decodeURIComponent(q[0]);q=2===q.length?decodeURIComponent(q[1]):"";"true"===q?q=!0:"false"===q&&(q=!1);var l=m.split(/\]\[?|\[/),r=d;-1<m.indexOf("[")&&l.pop();
-for(var f=0;f<l.length;f++){m=l[f];var n=l[f+1];n=""==n||!isNaN(parseInt(n,10));var p=f===l.length-1;""===m&&(m=l.slice(0,f).join(),null==h[m]&&(h[m]=0),m=h[m]++);null==r[m]&&(r[m]=p?q:n?[]:{});r=r[m]}}return d},W=function(b){function d(d){var f=b.location[d].replace(/(?:%[a-f89][a-f0-9])+/gim,decodeURIComponent);"pathname"===d&&"/"!==f[0]&&(f="/"+f);return f}function h(b){return function(){null==l&&(l=m(function(){l=null;b()}))}}function k(b,d,k){var a=b.indexOf("?"),f=b.indexOf("#"),h=-1<a?a:-1<
-f?f:b.length;if(-1<a){a=N(b.slice(a+1,-1<f?f:b.length));for(var l in a)d[l]=a[l]}if(-1<f)for(l in d=N(b.slice(f+1)),d)k[l]=d[l];return b.slice(0,h)}var q="function"===typeof b.history.pushState,m="function"===typeof setImmediate?setImmediate:setTimeout,l,r={prefix:"#!",getPath:function(){switch(r.prefix.charAt(0)){case "#":return d("hash").slice(r.prefix.length);case "?":return d("search").slice(r.prefix.length)+d("hash");default:return d("pathname").slice(r.prefix.length)+d("search")+d("hash")}},
-setPath:function(d,l,h){var a={},f={};d=k(d,a,f);if(null!=l){for(var m in l)a[m]=l[m];d=d.replace(/:([^\/]+)/g,function(b,d){delete a[d];return l[d]})}(m=E(a))&&(d+="?"+m);(f=E(f))&&(d+="#"+f);q?(f=h?h.state:null,m=h?h.title:null,b.onpopstate(),h&&h.replace?b.history.replaceState(f,m,r.prefix+d):b.history.pushState(f,m,r.prefix+d)):b.location.href=r.prefix+d},defineRoutes:function(d,l,m){function a(){var a=r.getPath(),f={},h=k(a,f,f),p=b.history.state;if(null!=p)for(var n in p)f[n]=p[n];for(var q in d)if(p=
-new RegExp("^"+q.replace(/:[^\/]+?\.{3}/g,"(.*?)").replace(/:[^\/]+/g,"([^\\/]+)")+"/?$"),p.test(h)){h.replace(p,function(){for(var b=q.match(/:[^\/]+/g)||[],k=[].slice.call(arguments,1,-2),h=0;h<b.length;h++)f[b[h].replace(/:|\./g,"")]=decodeURIComponent(k[h]);l(d[q],f,a,q)});return}m(a,f)}q?b.onpopstate=h(a):"#"===r.prefix.charAt(0)&&(b.onhashchange=a);a()}};return r};A.route=function(b,d){var h=W(b),k=function(b){return b},q,m,l,r,f,n=function(b,a,n){function p(){null!=q&&d.render(b,q(y(m,l.key,
-l)))}if(null==b)throw Error("Ensure the DOM element that was passed to `m.route` is not undefined");var v=function(){p();v=d.redraw};d.subscribe(b,p);var w=function(b){if(b!==a)h.setPath(a,null,{replace:!0});else throw Error("Could not resolve default route "+a);};h.defineRoutes(n,function(a,b,d){var h=f=function(a,p){h===f&&(m=null==p||"function"!==typeof p.view&&"function"!==typeof p?"div":p,l=b,r=d,f=null,q=(a.render||k).bind(a),v())};a.view||"function"===typeof a?h({},a):a.onmatch?V.resolve(a.onmatch(b,
-d)).then(function(b){h(a,b)},w):h(a,"div")},w)};n.set=function(b,a,d){null!=f&&(d=d||{},d.replace=!0);f=null;h.setPath(b,a,d)};n.get=function(){return r};n.prefix=function(b){h.prefix=b};n.link=function(b){b.dom.setAttribute("href",h.prefix+b.attrs.href);b.dom.onclick=function(a){a.ctrlKey||a.metaKey||a.shiftKey||2===a.which||(a.preventDefault(),a.redraw=!1,a=this.getAttribute("href"),0===a.indexOf(h.prefix)&&(a=a.slice(h.prefix.length)),n.set(a,void 0,void 0))}};n.param=function(b){return"undefined"!==
-typeof l&&"undefined"!==typeof b?l[b]:l};return n}(window,J);A.withAttr=function(b,d,h){return function(k){d.call(h||this,b in k.currentTarget?k.currentTarget[b]:k.currentTarget.getAttribute(b))}};var X=Q(window);A.render=X.render;A.redraw=J.redraw;A.request=M.request;A.jsonp=M.jsonp;A.parseQueryString=N;A.buildQueryString=E;A.version="1.1.3";A.vnode=y;"undefined"!==typeof module?module.exports=A:window.m=A})();
\ No newline at end of file
+(function(){function t(a,d,e,h,p,l){return{tag:a,key:d,attrs:e,children:h,text:p,dom:l,domSize:void 0,state:void 0,events:void 0,instance:void 0,skip:!1}}function Q(a){for(var d in a)if(G.call(a,d))return!1;return!0}function x(a){var d=arguments[1],e=2;if(null==a||"string"!==typeof a&&"function"!==typeof a&&"function"!==typeof a.view)throw Error("The selector must be either a string or a component.");if("string"===typeof a){var h;if(!(h=R[a])){var p="div";for(var l=[],k={};h=V.exec(a);){var q=h[1],
+r=h[2];""===q&&""!==r?p=r:"#"===q?k.id=r:"."===q?l.push(r):"["===h[3][0]&&((q=h[6])&&(q=q.replace(/\\(["'])/g,"$1").replace(/\\\\/g,"\\")),"class"===h[4]?l.push(q):k[h[4]]=""===q?q:q||!0)}0<l.length&&(k.className=l.join(" "));h=R[a]={tag:p,attrs:k}}}if(null==d)d={};else if("object"!==typeof d||null!=d.tag||Array.isArray(d))d={},e=1;if(arguments.length===e+1)p=arguments[e],Array.isArray(p)||(p=[p]);else for(p=[];e<arguments.length;)p.push(arguments[e++]);e=t.normalizeChildren(p);if("string"===typeof a){p=
+!1;var m,u;l=d.className||d["class"];if(!Q(h.attrs)&&!Q(d)){k={};for(var c in d)G.call(d,c)&&(k[c]=d[c]);d=k}for(c in h.attrs)G.call(h.attrs,c)&&(d[c]=h.attrs[c]);void 0!==l&&(void 0!==d["class"]&&(d["class"]=void 0,d.className=l),null!=h.attrs.className&&(d.className=h.attrs.className+" "+l));for(c in d)if(G.call(d,c)&&"key"!==c){p=!0;break}Array.isArray(e)&&1===e.length&&null!=e[0]&&"#"===e[0].tag?u=e[0].children:m=e;return t(h.tag,d.key,p?d:void 0,m,u)}return t(a,d.key,d,e)}function W(a){var d=
+0,e=null,h="function"===typeof requestAnimationFrame?requestAnimationFrame:setTimeout;return function(){var p=Date.now()-d;null===e&&(e=h(function(){e=null;a();d=Date.now()},16-p))}}t.normalize=function(a){return Array.isArray(a)?t("[",void 0,void 0,t.normalizeChildren(a),void 0,void 0):null!=a&&"object"!==typeof a?t("#",void 0,void 0,!1===a?"":a,void 0,void 0):a};t.normalizeChildren=function(a){for(var d=0;d<a.length;d++)a[d]=t.normalize(a[d]);return a};var V=/(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g,
+R={},G={}.hasOwnProperty;x.trust=function(a){null==a&&(a="");return t("<",void 0,void 0,a,void 0,void 0)};x.fragment=function(a,d){return t("[",a.key,a,t.normalizeChildren(d),void 0,void 0)};var B=function(a){function d(a,c){return function y(d){var A;try{if(!c||null==d||"object"!==typeof d&&"function"!==typeof d||"function"!==typeof(A=d.then))m(function(){c||0!==a.length||console.error("Possible unhandled promise rejection:",d);for(var e=0;e<a.length;e++)a[e](d);p.length=0;l.length=0;r.state=c;r.retry=
+function(){y(d)}});else{if(d===h)throw new TypeError("Promise can't be resolved w/ itself");e(A.bind(d))}}catch(Y){q(Y)}}}function e(a){function c(c){return function(a){0<d++||c(a)}}var d=0,r=c(q);try{a(c(k),r)}catch(y){r(y)}}if(!(this instanceof B))throw Error("Promise must be called with `new`");if("function"!==typeof a)throw new TypeError("executor must be a function");var h=this,p=[],l=[],k=d(p,!0),q=d(l,!1),r=h._instance={resolvers:p,rejectors:l},m="function"===typeof setImmediate?setImmediate:
+setTimeout;e(a)};B.prototype.then=function(a,d){function e(a,d,e,k){d.push(function(c){if("function"!==typeof a)e(c);else try{p(a(c))}catch(C){l&&l(C)}});"function"===typeof h.retry&&k===h.state&&h.retry()}var h=this._instance,p,l,k=new B(function(a,d){p=a;l=d});e(a,h.resolvers,p,!0);e(d,h.rejectors,l,!1);return k};B.prototype["catch"]=function(a){return this.then(null,a)};B.resolve=function(a){return a instanceof B?a:new B(function(d){d(a)})};B.reject=function(a){return new B(function(d,e){e(a)})};
+B.all=function(a){return new B(function(d,e){var h=a.length,p=0,l=[];if(0===a.length)d([]);else for(var k=0;k<a.length;k++)(function(k){function r(a){p++;l[k]=a;p===h&&d(l)}null==a[k]||"object"!==typeof a[k]&&"function"!==typeof a[k]||"function"!==typeof a[k].then?r(a[k]):a[k].then(r,e)})(k)})};B.race=function(a){return new B(function(d,e){for(var h=0;h<a.length;h++)a[h].then(d,e)})};"undefined"!==typeof window?("undefined"===typeof window.Promise&&(window.Promise=B),B=window.Promise):"undefined"!==
+typeof global&&("undefined"===typeof global.Promise&&(global.Promise=B),B=global.Promise);var F=function(a){function d(a,h){if(Array.isArray(h))for(var k=0;k<h.length;k++)d(a+"["+k+"]",h[k]);else if("[object Object]"===Object.prototype.toString.call(h))for(k in h)d(a+"["+k+"]",h[k]);else e.push(encodeURIComponent(a)+(null!=h&&""!==h?"="+encodeURIComponent(h):""))}if("[object Object]"!==Object.prototype.toString.call(a))return"";var e=[],h;for(h in a)d(h,a[h]);return e.join("&")},Z=/^file:\/\//i,O=
+function(a,d){function e(){function c(){0===--a&&"function"===typeof u&&u()}var a=0;return function X(d){var e=d.then;d.then=function(){a++;var r=e.apply(d,arguments);r.then(c,function(d){c();if(0===a)throw d;});return X(r)};return d}}function h(c,a){if("string"===typeof c){var d=c;c=a||{};null==c.url&&(c.url=d)}return c}function p(c,a){if(null==a)return c;for(var d=c.match(/:[^\/]+/gi)||[],e=0;e<d.length;e++){var r=d[e].slice(1);null!=a[r]&&(c=c.replace(d[e],a[r]))}return c}function l(c,a){var d=
+F(a);if(""!==d){var e=0>c.indexOf("?")?"?":"&";c+=e+d}return c}function k(c){try{return""!==c?JSON.parse(c):null}catch(C){throw Error(c);}}function q(c){return c.responseText}function r(c,a){if("function"===typeof c)if(Array.isArray(a))for(var d=0;d<a.length;d++)a[d]=new c(a[d]);else return new c(a);return a}var m=0,u;return{request:function(c,m){var A=e();c=h(c,m);var C=new d(function(d,e){null==c.method&&(c.method="GET");c.method=c.method.toUpperCase();var h="GET"===c.method||"TRACE"===c.method?
+!1:"boolean"===typeof c.useBody?c.useBody:!0;"function"!==typeof c.serialize&&(c.serialize="undefined"!==typeof FormData&&c.data instanceof FormData?function(c){return c}:JSON.stringify);"function"!==typeof c.deserialize&&(c.deserialize=k);"function"!==typeof c.extract&&(c.extract=q);c.url=p(c.url,c.data);h?c.data=c.serialize(c.data):c.url=l(c.url,c.data);var m=new a.XMLHttpRequest,A=!1,C=m.abort;m.abort=function(){A=!0;C.call(m)};m.open(c.method,c.url,"boolean"===typeof c.async?c.async:!0,"string"===
+typeof c.user?c.user:void 0,"string"===typeof c.password?c.password:void 0);c.serialize!==JSON.stringify||!h||c.headers&&c.headers.hasOwnProperty("Content-Type")||m.setRequestHeader("Content-Type","application/json; charset=utf-8");c.deserialize!==k||c.headers&&c.headers.hasOwnProperty("Accept")||m.setRequestHeader("Accept","application/json, text/*");c.withCredentials&&(m.withCredentials=c.withCredentials);c.timeout&&(m.timeout=c.timeout);for(var u in c.headers)({}).hasOwnProperty.call(c.headers,
+u)&&m.setRequestHeader(u,c.headers[u]);"function"===typeof c.config&&(m=c.config(m,c)||m);m.onreadystatechange=function(){if(!A&&4===m.readyState)try{var a=c.extract!==q?c.extract(m,c):c.deserialize(c.extract(m,c));if(c.extract!==q||200<=m.status&&300>m.status||304===m.status||Z.test(c.url))d(r(c.type,a));else{var h=Error(m.responseText);h.code=m.status;h.response=a;e(h)}}catch(H){e(H)}};h&&null!=c.data?m.send(c.data):m.send()});return!0===c.background?C:A(C)},jsonp:function(c,k){var A=e();c=h(c,
+k);var q=new d(function(d,e){var h=c.callbackName||"_mithril_"+Math.round(1E16*Math.random())+"_"+m++,k=a.document.createElement("script");a[h]=function(e){k.parentNode.removeChild(k);d(r(c.type,e));delete a[h]};k.onerror=function(){k.parentNode.removeChild(k);e(Error("JSONP request failed"));delete a[h]};null==c.data&&(c.data={});c.url=p(c.url,c.data);c.data[c.callbackKey||"callback"]=h;k.src=l(c.url,c.data);a.document.documentElement.appendChild(k)});return!0===c.background?q:A(q)},setCompletionCallback:function(c){u=
+c}}}(window,B),U=function(a){function d(g,b){if(g.state!==b)throw Error("`vnode.state` must not be modified");}function e(g){var b=g.state;try{return this.apply(b,arguments)}finally{d(g,b)}}function h(g,b,f,c,a,d,e){for(;f<c;f++){var h=b[f];null!=h&&p(g,h,a,e,d)}}function p(g,b,f,a,d){var e=b.tag;if("string"===typeof e)switch(b.state={},null!=b.attrs&&K(b.attrs,b,f),e){case "#":return b.dom=D.createTextNode(b.children),c(g,b.dom,d),b.dom;case "<":return l(g,b,d);case "[":var r=D.createDocumentFragment();
+null!=b.children&&(e=b.children,h(r,e,0,e.length,f,null,a));b.dom=r.firstChild;b.domSize=r.childNodes.length;c(g,r,d);return r;default:var n=b.tag,m=(e=b.attrs)&&e.is;n=(a=b.attrs&&b.attrs.xmlns||G[b.tag]||a)?m?D.createElementNS(a,n,{is:m}):D.createElementNS(a,n):m?D.createElement(n,{is:m}):D.createElement(n);b.dom=n;if(null!=e)for(r in m=a,e)J(b,r,null,e[r],m);c(g,n,d);null!=b.attrs&&null!=b.attrs.contenteditable?C(b):(null!=b.text&&(""!==b.text?n.textContent=b.text:b.children=[t("#",void 0,void 0,
+b.text,void 0,void 0)]),null!=b.children&&(g=b.children,h(n,g,0,g.length,f,null,a),g=b.attrs,"select"===b.tag&&null!=g&&("value"in g&&J(b,"value",null,g.value,void 0),"selectedIndex"in g&&J(b,"selectedIndex",null,g.selectedIndex,void 0))));return n}else return k(b,f),null!=b.instance?(f=p(g,b.instance,f,a,d),b.dom=b.instance.dom,b.domSize=null!=b.dom?b.instance.domSize:0,c(g,f,d),b=f):(b.domSize=0,b=H),b}function l(g,b,f){var a={caption:"table",thead:"table",tbody:"table",tfoot:"table",tr:"tbody",
+th:"tr",td:"tr",colgroup:"table",col:"colgroup"}[(b.children.match(/^\s*?<(\w+)/im)||[])[1]]||"div";a=D.createElement(a);a.innerHTML=b.children;b.dom=a.firstChild;b.domSize=a.childNodes.length;b=D.createDocumentFragment();for(var d;d=a.firstChild;)b.appendChild(d);c(g,b,f);return b}function k(g,b){if("function"===typeof g.tag.view){g.state=Object.create(g.tag);var f=g.state.view;if(null!=f.$$reentrantLock$$)return H;f.$$reentrantLock$$=!0}else{g.state=void 0;f=g.tag;if(null!=f.$$reentrantLock$$)return H;
+f.$$reentrantLock$$=!0;g.state=null!=g.tag.prototype&&"function"===typeof g.tag.prototype.view?new g.tag(g):g.tag(g)}null!=g.attrs&&K(g.attrs,g,b);K(g.state,g,b);g.instance=t.normalize(e.call(g.state.view,g));if(g.instance===g)throw Error("A view cannot return the vnode it received as argument");f.$$reentrantLock$$=null}function q(g,b,f,a,d,e,k){if(!(b===f&&!a||null==b&&null==f))if(null==b)h(g,f,0,f.length,d,e,k);else if(null==f)A(b,0,b.length,f,a);else{for(var n=0,l=Math.min(b.length,f.length),q=
+b.length,C=!1,E=!1;n<l;n++)if(null!=b[n]&&null!=f[n]){null==b[n].key&&null==f[n].key&&(E=!0);break}if(E&&q===f.length)for(n=0;n<q;n++)b[n]===f[n]&&!a||null==b[n]&&null==f[n]||(null==b[n]?p(g,f[n],d,k,u(b,n+1,q,e)):null==f[n]?A(b,n,n+1,f,a):r(g,b[n],f[n],d,u(b,n+1,q,e),a,k));else{a:{if(null!=b.pool&&Math.abs(b.pool.length-f.length)<=Math.abs(b.length-f.length)&&(n=f[0]&&f[0].children&&f[0].children.length||0,Math.abs((b.pool[0]&&b.pool[0].children&&b.pool[0].children.length||0)-n)<=Math.abs((b[0]&&
+b[0].children&&b[0].children.length||0)-n))){n=!0;break a}n=!1}n&&(C=!0,b=b.concat(b.pool));var v=n=0;l=b.length-1;for(var t=f.length-1,I,w,z,y;l>=v&&t>=n;)if(w=b[v],z=f[n],y=C&&v>=q,w===z&&!y&&!a||null==w&&null==z)v++,n++;else if(null==w)(E||null==z.key)&&p(g,f[n],d,k,u(b,++n,q,e)),v++;else if(null==z){if(E||null==w.key)A(b,n,n+1,f,a),v++;n++}else if(w.key===z.key)v++,n++,r(g,w,z,d,u(b,v,q,e),y||a,k),y&&w.tag===z.tag&&c(g,m(z),e);else if(w=b[l],y=C&&l>=q,w!==z||y||a)if(null==w)l--;else if(null==
+z)n++;else if(w.key===z.key)r(g,w,z,d,u(b,l+1,q,e),y||a,k),(y&&w.tag===z.tag||n<t)&&c(g,m(z),u(b,v,q,e)),l--,n++;else break;else l--,n++;for(;l>=v&&t>=n;){w=b[l];z=f[t];y=C&&l>=q;if(w!==z||y||a)if(null==w)l--;else{if(null!=z)if(w.key===z.key)r(g,w,z,d,u(b,l+1,q,e),y||a,k),y&&w.tag===z.tag&&c(g,m(z),e),null!=w.dom&&(e=w.dom),l--;else{if(!I){I=b;E=l;w={};for(y=0;y<E;y++){var x=I[y];null!=x&&(x=x.key,null!=x&&(w[x]=y))}I=w}null!=z&&(E=I[z.key],null!=E?(w=b[E],y=C&&E>=q,r(g,w,z,d,u(b,l+1,q,e),y||a,k),
+c(g,m(z),e),w.skip=!0,null!=w.dom&&(e=w.dom)):e=p(g,z,d,k,e))}t--}else l--,t--;if(t<n)break}h(g,f,n,t+1,d,e,k);A(b,v,Math.min(l+1,q),f,a);if(C)for(g=Math.max(v,q);l>=g;l--)b[l].skip?b[l].skip=!1:B(b[l],f)}}}function r(g,b,f,a,c,d,h){var n=b.tag;if(n===f.tag){f.state=b.state;f.events=b.events;var A;if(A=!d){var u,E;null!=f.attrs&&"function"===typeof f.attrs.onbeforeupdate&&(u=e.call(f.attrs.onbeforeupdate,f,b));"string"!==typeof f.tag&&"function"===typeof f.state.onbeforeupdate&&(E=e.call(f.state.onbeforeupdate,
+f,b));void 0===u&&void 0===E||u||E?A=!1:(f.dom=b.dom,f.domSize=b.domSize,f.instance=b.instance,A=!0)}if(!A)if("string"===typeof n)switch(null!=f.attrs&&(d?(f.state={},K(f.attrs,f,a)):M(f.attrs,f,a)),n){case "#":b.children.toString()!==f.children.toString()&&(b.dom.nodeValue=f.children);f.dom=b.dom;break;case "<":b.children!==f.children?(m(b),l(g,f,c)):(f.dom=b.dom,f.domSize=b.domSize);break;case "[":q(g,b.children,f.children,d,a,c,h);b=0;a=f.children;f.dom=null;if(null!=a){for(d=0;d<a.length;d++){var v=
+a[d];null!=v&&null!=v.dom&&(null==f.dom&&(f.dom=v.dom),b+=v.domSize||1)}1!==b&&(f.domSize=b)}break;default:g=f.dom=b.dom;h=f.attrs&&f.attrs.xmlns||G[f.tag]||h;"textarea"===f.tag&&(null==f.attrs&&(f.attrs={}),null!=f.text&&(f.attrs.value=f.text,f.text=void 0));c=b.attrs;n=f.attrs;A=h;if(null!=n)for(v in n)J(f,v,c&&c[v],n[v],A);if(null!=c)for(v in c)null!=n&&v in n||("className"===v&&(v="class"),"o"!==v[0]||"n"!==v[1]||S(v)?"key"!==v&&f.dom.removeAttribute(v):T(f,v,void 0));null!=f.attrs&&null!=f.attrs.contenteditable?
+C(f):null!=b.text&&null!=f.text&&""!==f.text?b.text.toString()!==f.text.toString()&&(b.dom.firstChild.nodeValue=f.text):(null!=b.text&&(b.children=[t("#",void 0,void 0,b.text,void 0,b.dom.firstChild)]),null!=f.text&&(f.children=[t("#",void 0,void 0,f.text,void 0,void 0)]),q(g,b.children,f.children,d,a,null,h))}else{if(d)k(f,a);else{f.instance=t.normalize(e.call(f.state.view,f));if(f.instance===f)throw Error("A view cannot return the vnode it received as argument");null!=f.attrs&&M(f.attrs,f,a);M(f.state,
+f,a)}null!=f.instance?(null==b.instance?p(g,f.instance,a,h,c):r(g,b.instance,f.instance,a,c,d,h),f.dom=f.instance.dom,f.domSize=f.instance.domSize):null!=b.instance?(y(b.instance,null,d),f.dom=void 0,f.domSize=0):(f.dom=b.dom,f.domSize=b.domSize)}}else y(b,null,d),p(g,f,a,h,c)}function m(g){var b=g.domSize;if(null!=b||null==g.dom){var a=D.createDocumentFragment();if(0<b){for(g=g.dom;--b;)a.appendChild(g.nextSibling);a.insertBefore(g,a.firstChild)}return a}return g.dom}function u(g,b,a,c){for(;b<a;b++)if(null!=
+g[b]&&null!=g[b].dom)return g[b].dom;return c}function c(g,b,a){a?g.insertBefore(b,a):g.appendChild(b)}function C(g){var b=g.children;if(null!=b&&1===b.length&&"<"===b[0].tag)b=b[0].children,g.dom.innerHTML!==b&&(g.dom.innerHTML=b);else if(null!=g.text||null!=b&&0!==b.length)throw Error("Child node of a contenteditable must be trusted");}function A(g,b,a,c,d){for(;b<a;b++){var f=g[b];null!=f&&(f.skip?f.skip=!1:y(f,c,d))}}function y(a,b,c){function g(){if(++h===f&&(c||(d(a,r),x(a)),a.dom)){var g=a.domSize||
+1;if(1<g)for(var e=a.dom;--g;){var n=e.nextSibling,k=n.parentNode;null!=k&&k.removeChild(n)}g=a.dom;e=g.parentNode;null!=e&&e.removeChild(g);B(a,b)}}var f=1,h=0;if(!c){var r=a.state;if(a.attrs&&"function"===typeof a.attrs.onbeforeremove){var k=e.call(a.attrs.onbeforeremove,a);null!=k&&"function"===typeof k.then&&(f++,k.then(g,g))}"string"!==typeof a.tag&&"function"===typeof a.state.onbeforeremove&&(k=e.call(a.state.onbeforeremove,a),null!=k&&"function"===typeof k.then&&(f++,k.then(g,g)))}g()}function B(a,
+b){var c;if(c=null!=b&&null==a.domSize)c=a.attrs,c=!(null!=c&&(c.oncreate||c.onupdate||c.onbeforeremove||c.onremove));c&&"string"===typeof a.tag&&(b.pool?b.pool.push(a):b.pool=[a])}function x(a){a.attrs&&"function"===typeof a.attrs.onremove&&e.call(a.attrs.onremove,a);if("string"!==typeof a.tag)"function"===typeof a.state.onremove&&e.call(a.state.onremove,a),null!=a.instance&&x(a.instance);else if(a=a.children,Array.isArray(a))for(var b=0;b<a.length;b++){var c=a[b];null!=c&&x(c)}}function J(a,b,c,
+d,e){if("key"!==b&&"is"!==b&&!S(b)){if("o"===b[0]&&"n"===b[1])return T(a,b,d);if((c!==d||"value"===b||"checked"===b||"selectedIndex"===b||"selected"===b&&a.dom===D.activeElement||a.dom.parentNode===D.activeElement||"object"===typeof d)&&void 0!==d){var f=a.dom;if("xlink:"===b.slice(0,6))f.setAttributeNS("http://www.w3.org/1999/xlink",b,d);else if("style"===b)if(a=c,null!=a&&null!=d&&"object"===typeof a&&"object"===typeof d&&d!==a){for(var g in d)d[g]!==a[g]&&(f.style[g]=d[g]);for(g in a)g in d||(f.style[g]=
+"")}else if(a===d&&(f.style.cssText="",a=null),null==d)f.style.cssText="";else if("string"===typeof d)f.style.cssText=d;else for(g in"string"===typeof a&&(f.style.cssText=""),d)f.style[g]=d[g];else if(b in f&&"href"!==b&&"list"!==b&&"form"!==b&&"width"!==b&&"height"!==b&&void 0===e&&!(a.attrs.is||-1<a.tag.indexOf("-"))){if("value"===b){g=""+d;if(("input"===a.tag||"textarea"===a.tag)&&a.dom.value===g&&a.dom===D.activeElement)return;if("select"===a.tag)if(null===d){if(-1===a.dom.selectedIndex&&a.dom===
+D.activeElement)return}else if(null!==c&&a.dom.value===g&&a.dom===D.activeElement)return;if("option"===a.tag&&null!=c&&a.dom.value===g)return}"input"===a.tag&&"type"===b?f.setAttribute(b,d):f[b]=d}else"boolean"===typeof d?d?f.setAttribute(b,""):f.removeAttribute(b):f.setAttribute("className"===b?"class":b,d)}}}function S(a){return"oninit"===a||"oncreate"===a||"onupdate"===a||"onremove"===a||"onbeforeremove"===a||"onbeforeupdate"===a}function N(){}function T(a,b,c){null!=a.events?a.events[b]!==c&&
+(null==c||"function"!==typeof c&&"object"!==typeof c?(null!=a.events[b]&&a.dom.removeEventListener(b.slice(2),a.events,!1),a.events[b]=void 0):(null==a.events[b]&&a.dom.addEventListener(b.slice(2),a.events,!1),a.events[b]=c)):null==c||"function"!==typeof c&&"object"!==typeof c||(a.events=new N,a.dom.addEventListener(b.slice(2),a.events,!1),a.events[b]=c)}function K(a,b,c){"function"===typeof a.oninit&&e.call(a.oninit,b);"function"===typeof a.oncreate&&c.push(e.bind(a.oncreate,b))}function M(a,b,c){"function"===
+typeof a.onupdate&&c.push(e.bind(a.onupdate,b))}var D=a.document,H=D.createDocumentFragment(),G={svg:"http://www.w3.org/2000/svg",math:"http://www.w3.org/1998/Math/MathML"},F;N.prototype=Object.create(null);N.prototype.handleEvent=function(a){var b=this["on"+a.type];"function"===typeof b?b.call(a.target,a):"function"===typeof b.handleEvent&&b.handleEvent(a);"function"===typeof F&&F.call(a.target,a)};return{render:function(a,b){if(!a)throw Error("Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.");
+var c=[],d=D.activeElement,e=a.namespaceURI;null==a.vnodes&&(a.textContent="");Array.isArray(b)||(b=[b]);q(a,a.vnodes,t.normalizeChildren(b),!1,c,null,"http://www.w3.org/1999/xhtml"===e?void 0:e);a.vnodes=b;null!=d&&D.activeElement!==d&&d.focus();for(d=0;d<c.length;d++)c[d]()},setEventCallback:function(a){return F=a}}},L=function(a,d){function e(a){a=l.indexOf(a);-1<a&&l.splice(a,2)}function h(){if(k)throw Error("Nested m.redraw.sync() call");k=!0;for(var a=1;a<l.length;a+=2)try{l[a]()}catch(m){"undefined"!==
+typeof console&&console.error(m)}k=!1}var p=U(a);p.setEventCallback(function(a){!1===a.redraw?a.redraw=void 0:q()});var l=[],k=!1,q=(d||W)(h);q.sync=h;return{subscribe:function(a,d){e(a);l.push(a,d)},unsubscribe:e,redraw:q,render:p.render}}(window);O.setCompletionCallback(L.redraw);x.mount=function(a){return function(d,e){if(null===e)a.render(d,[]),a.unsubscribe(d);else{if(null==e.view&&"function"!==typeof e)throw Error("m.mount(element, component) expects a component, not a vnode");var h=function(){a.render(d,
+t(e))};a.subscribe(d,h);h()}}}(L);var aa=B,P=function(a){if(""===a||null==a)return{};"?"===a.charAt(0)&&(a=a.slice(1));a=a.split("&");for(var d={},e={},h=0;h<a.length;h++){var p=a[h].split("="),l=decodeURIComponent(p[0]);p=2===p.length?decodeURIComponent(p[1]):"";"true"===p?p=!0:"false"===p&&(p=!1);var k=l.split(/\]\[?|\[/),q=d;-1<l.indexOf("[")&&k.pop();for(var r=0;r<k.length;r++){l=k[r];var m=k[r+1];m=""==m||!isNaN(parseInt(m,10));var u=r===k.length-1;""===l&&(l=k.slice(0,r).join(),null==e[l]&&
+(e[l]=0),l=e[l]++);null==q[l]&&(q[l]=u?p:m?[]:{});q=q[l]}}return d},ba=function(a){function d(d){var e=a.location[d].replace(/(?:%[a-f89][a-f0-9])+/gim,decodeURIComponent);"pathname"===d&&"/"!==e[0]&&(e="/"+e);return e}function e(a){return function(){null==k&&(k=l(function(){k=null;a()}))}}function h(a,d,e){var c=a.indexOf("?"),h=a.indexOf("#"),k=-1<c?c:-1<h?h:a.length;if(-1<c){c=P(a.slice(c+1,-1<h?h:a.length));for(var l in c)d[l]=c[l]}if(-1<h)for(l in d=P(a.slice(h+1)),d)e[l]=d[l];return a.slice(0,
+k)}var p="function"===typeof a.history.pushState,l="function"===typeof setImmediate?setImmediate:setTimeout,k,q={prefix:"#!",getPath:function(){switch(q.prefix.charAt(0)){case "#":return d("hash").slice(q.prefix.length);case "?":return d("search").slice(q.prefix.length)+d("hash");default:return d("pathname").slice(q.prefix.length)+d("search")+d("hash")}},setPath:function(d,e,k){var c={},l={};d=h(d,c,l);if(null!=e){for(var m in e)c[m]=e[m];d=d.replace(/:([^\/]+)/g,function(a,d){delete c[d];return e[d]})}(m=
+F(c))&&(d+="?"+m);(l=F(l))&&(d+="#"+l);p?(l=k?k.state:null,m=k?k.title:null,a.onpopstate(),k&&k.replace?a.history.replaceState(l,m,q.prefix+d):a.history.pushState(l,m,q.prefix+d)):a.location.href=q.prefix+d},defineRoutes:function(d,k,l){function c(){var c=q.getPath(),e={},m=h(c,e,e),p=a.history.state;if(null!=p)for(var r in p)e[r]=p[r];for(var t in d)if(p=new RegExp("^"+t.replace(/:[^\/]+?\.{3}/g,"(.*?)").replace(/:[^\/]+/g,"([^\\/]+)")+"/?$"),p.test(m)){m.replace(p,function(){for(var a=t.match(/:[^\/]+/g)||
+[],h=[].slice.call(arguments,1,-2),l=0;l<a.length;l++)e[a[l].replace(/:|\./g,"")]=decodeURIComponent(h[l]);k(d[t],e,c,t)});return}l(c,e)}p?a.onpopstate=e(c):"#"===q.prefix.charAt(0)&&(a.onhashchange=c);c()}};return q};x.route=function(a,d){var e=ba(a),h=function(a){return a},p,l,k,q,r,m=function(a,m,A){function c(){null!=p&&d.render(a,p(t(l,k.key,k)))}if(null==a)throw Error("Ensure the DOM element that was passed to `m.route` is not undefined");var u=function(){c();u=d.redraw};d.subscribe(a,c);var x=
+function(a){if(a!==m)e.setPath(m,null,{replace:!0});else throw Error("Could not resolve default route "+m);};e.defineRoutes(A,function(a,c,d){var e=r=function(a,m){e===r&&(l=null==m||"function"!==typeof m.view&&"function"!==typeof m?"div":m,k=c,q=d,r=null,p=(a.render||h).bind(a),u())};a.view||"function"===typeof a?e({},a):a.onmatch?aa.resolve(a.onmatch(c,d)).then(function(c){e(a,c)},x):e(a,"div")},x)};m.set=function(a,d,h){null!=r&&(h=h||{},h.replace=!0);r=null;e.setPath(a,d,h)};m.get=function(){return q};
+m.prefix=function(a){e.prefix=a};var u=function(a,d){d.dom.setAttribute("href",e.prefix+d.attrs.href);d.dom.onclick=function(c){c.ctrlKey||c.metaKey||c.shiftKey||2===c.which||(c.preventDefault(),c.redraw=!1,c=this.getAttribute("href"),0===c.indexOf(e.prefix)&&(c=c.slice(e.prefix.length)),m.set(c,void 0,a))}};m.link=function(a){return null==a.tag?u.bind(u,a):u({},a)};m.param=function(a){return"undefined"!==typeof k&&"undefined"!==typeof a?k[a]:k};return m}(window,L);x.withAttr=function(a,d,e){return function(h){d.call(e||
+this,a in h.currentTarget?h.currentTarget[a]:h.currentTarget.getAttribute(a))}};var ca=U(window);x.render=ca.render;x.redraw=L.redraw;x.request=O.request;x.jsonp=O.jsonp;x.parseQueryString=P;x.buildQueryString=F;x.version="1.1.3";x.vnode=t;"undefined"!==typeof module?module.exports=x:window.m=x})();
\ No newline at end of file
diff --git a/ospec/README.md b/ospec/README.md
index dc3d923e..9b0b416c 100644
--- a/ospec/README.md
+++ b/ospec/README.md
@@ -7,7 +7,7 @@ Noiseless testing framework
 
 ## About
 
-- ~180 LOC
+- ~330 LOC including the CLI runner
 - terser and faster test code than with mocha, jasmine or tape
 - test code reads like bullet points
 - assertion code follows [SVO](https://en.wikipedia.org/wiki/Subject–verb–object) structure in present tense for terseness and readability
@@ -19,7 +19,7 @@ Noiseless testing framework
 	- `before`/`after`/`beforeEach`/`afterEach` hooks
 	- test exclusivity (i.e. `.only`)
 	- async tests and hooks
-- explicitly disallows test-space configuration to encourage focus on testing, and to provide uniform test suites across projects
+- explicitly regulates test-space configuration to encourage focus on testing, and to provide uniform test suites across projects
 
 ## Usage
 
@@ -311,7 +311,9 @@ ospec will automatically evaluate all `*.js` files in any folder named `/tests`.
 
 Ospec doesn't work when installed globally. Using global scripts is generally a bad idea since you can end up with different, incompatible versions of the same package installed locally and globally.
 
-To work around this limitation, you can use [`npm-run`](https://www.npmjs.com/package/npm-run) which enables one to run the binaries of locally installed packages.
+If you're using a recent version of npm (v5+), you can use run `npx ospec` from your project folder.
+
+Otherwise, to work around this limitation, you can use [`npm-run`](https://www.npmjs.com/package/npm-run) which enables one to run the binaries of locally installed packages.
 
 ```
 npm install npm-run -g
@@ -437,9 +439,24 @@ The arguments that were passed to the function in the last time it was called
 
 ---
 
-### void o.run()
+### void o.run([Function reporter])
 
-Runs the test suite
+Runs the test suite. By default passing test results are printed using
+`console.log` and failing test results are printed using `console.error`.
+
+If you have custom continuous integration needs then you can use a
+reporter to process [test result data](#result-data) yourself.
+
+If running in Node.js, ospec will call `process.exit` after reporting
+results by default. If you specify a reporter, ospec will not do this
+and allow your reporter to respond to results in its own way.
+
+
+---
+
+### Number o.report(results)
+
+The default reporter used by `o.run()` when none are provided. Returns the number of failures, doesn't exit Node.js by itself. It expects an array of [test result data](#result-data) as argument.
 
 ---
 
@@ -455,6 +472,74 @@ $o("a test", function() {
 $o.run()
 ```
 
+---
+
+## Result data
+
+Test results are available by reference for integration purposes. You
+can use custom reporters in `o.run()` to process these results.
+
+```javascript
+o.run(function(results) {
+	// results is an array
+
+	results.forEach(function(result) {
+		// ...
+	})
+})
+```
+
+---
+
+### Boolean result.pass
+
+True if the test passed. **No other keys will exist on the result if this value is true.**
+
+---
+
+### Error result.error
+
+The `Error` object explaining the reason behind a failure.
+
+---
+
+### String result.message
+
+If an exception was thrown inside the corresponding test, this will equal that Error's `message`. Otherwise, this will be a preformatted message in [SVO form](https://en.wikipedia.org/wiki/Subject%E2%80%93verb%E2%80%93object). More specifically, `${subject}\n${verb}\n${object}`.
+
+As an example, the following test's result message will be `"false\nshould equal\ntrue"`.
+
+```javascript
+o.spec("message", function() {
+	o(false).equals(true)
+})
+```
+
+If you specify an assertion description, that description will appear two lines above the subject.
+
+```javascript
+o.spec("message", function() {
+	o(false).equals(true)("Candyland") // result.message === "Candyland\n\nfalse\nshould equal\ntrue"
+})
+```
+
+---
+
+### String result.context
+
+A `>`-separated string showing the structure of the test specification.
+In the below example, `result.context` would be `testing > rocks`.
+
+```javascript
+o.spec("testing", function() {
+	o.spec("rocks", function() {
+		o(false).equals(true)
+	})
+})
+```
+
+
+
 ---
 
 ## Goals
@@ -462,8 +547,8 @@ $o.run()
 - Do the most common things that the mocha/chai/sinon triad does without having to install 3 different libraries and several dozen dependencies
 - Disallow configuration in test-space:
 	- Disallow ability to pick between API styles (BDD/TDD/Qunit, assert/should/expect, etc)
-	- Disallow ability to pick between different reporters
 	- Disallow ability to add custom assertion types
+	- Provide a default simple reporter
 - Make assertion code terse, readable and self-descriptive
 - Have as few assertion types as possible for a workable usage pattern
 
diff --git a/ospec/ospec.js b/ospec/ospec.js
index 147e2dc4..9769bccd 100644
--- a/ospec/ospec.js
+++ b/ospec/ospec.js
@@ -1,11 +1,16 @@
-/* eslint-disable no-bitwise, no-process-exit */
+/* eslint-disable global-require, no-bitwise, no-process-exit */
 "use strict"
-
-module.exports = new function init(name) {
+;(function(m) {
+if (typeof module !== "undefined") module["exports"] = m()
+else window.o = m()
+})(function init(name) {
 	var spec = {}, subjects = [], results, only = null, ctx = spec, start, stack = 0, nextTickish, hasProcess = typeof process === "object", hasOwn = ({}).hasOwnProperty
 
 	if (name != null) spec[name] = ctx = {}
 
+	try {throw new Error} catch (e) {
+		var ospecFileName = e.stack && (/[\/\\](.*?):\d+:\d+/).test(e.stack) ? e.stack.match(/[\/\\](.*?):\d+:\d+/)[1] : null
+	}
 	function o(subject, predicate) {
 		if (predicate === undefined) {
 			if (results == null) throw new Error("Assertions should not occur outside test definitions")
@@ -49,10 +54,35 @@ module.exports = new function init(name) {
 		spy.callCount = 0
 		return spy
 	}
-	o.run = function() {
+	o.cleanStackTrace = function(error) {
+		// For IE 10+ in quirks mode, and IE 9- in any mode, errors don't have a stack
+		if (error.stack == null) return ""
+		var i = 0, header = error.message ? error.name + ": " + error.message : error.name, stack
+		// some environments add the name and message to the stack trace
+		if (error.stack.indexOf(header) === 0) {
+			stack = error.stack.slice(header.length).split(/\r?\n/)
+			stack.shift() // drop the initial empty string
+		} else {
+			stack = error.stack.split(/\r?\n/)
+		}
+		if (ospecFileName == null) return stack.join("\n")
+		// skip ospec-related entries on the stack
+		while (stack[i].indexOf(ospecFileName) !== -1) i++
+		// now we're in user code
+		return stack[i]
+	}
+	o.run = function(reporter) {
 		results = []
 		start = new Date
-		test(spec, [], [], report)
+		test(spec, [], [], function() {
+			setTimeout(function () {
+				if (typeof reporter === "function") reporter(results)
+				else {
+					var errCount = o.report(results)
+					if (hasProcess && errCount !== 0) process.exit(1)
+				}
+			})
+		})
 
 		function test(spec, pre, post, finalize) {
 			pre = [].concat(pre, spec["__beforeEach"] || [])
@@ -217,7 +247,8 @@ module.exports = new function init(name) {
 			}
 			result.context = subjects.join(" > ")
 			result.message = message
-			result.error = error.stack
+			result.error = error
+
 		}
 		results.push(result)
 	}
@@ -231,13 +262,13 @@ module.exports = new function init(name) {
 		return hasProcess ? "\x1b[31m" + message + "\x1b[0m" : "%c" + message + "%c "
 	}
 
-	function report() {
-		var status = 0
+	o.report = function (results) {
+		var errCount = 0
 		for (var i = 0, r; r = results[i]; i++) {
 			if (!r.pass) {
-				var stackTrace = r.error.match(/^(?:(?!Error|[\/\\]ospec[\/\\]ospec\.js).)*$/m)
+				var stackTrace = o.cleanStackTrace(r.error)
 				console.error(r.context + ":\n" + highlight(r.message) + (stackTrace ? "\n\n" + stackTrace + "\n\n" : ""), hasProcess ? "" : "color:red", hasProcess ? "" : "color:black")
-				status = 1
+				errCount++
 			}
 		}
 		console.log(
@@ -245,10 +276,10 @@ module.exports = new function init(name) {
 			results.length + " assertions completed in " + Math.round(new Date - start) + "ms, " +
 			"of which " + results.filter(function(result){return result.error}).length + " failed"
 		)
-		if (hasProcess && status === 1) process.exit(1)
+		return errCount
 	}
 
-	if(hasProcess) {
+	if (hasProcess) {
 		nextTickish = process.nextTick
 	} else {
 		nextTickish = function fakeFastNextTick(next) {
@@ -258,4 +289,4 @@ module.exports = new function init(name) {
 	}
 
 	return o
-}
+})
diff --git a/ospec/package.json b/ospec/package.json
index 7cfa4595..acc0ae47 100644
--- a/ospec/package.json
+++ b/ospec/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ospec",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Noiseless testing framework",
   "main": "ospec.js",
   "directories": {
diff --git a/ospec/tests/test-ospec.js b/ospec/tests/test-ospec.js
index 69f2e1f1..526671c6 100644
--- a/ospec/tests/test-ospec.js
+++ b/ospec/tests/test-ospec.js
@@ -18,6 +18,77 @@ new function(o) {
 	o.run()
 }(o)
 
+new function(o) {
+	var clone = o.new()
+
+	clone.spec("clone", function() {
+		clone("fail", function() {
+			clone(true).equals(false)
+		})
+
+		clone("pass", function() {
+			clone(true).equals(true)
+		})
+	})
+
+	// Predicate test passing on clone results
+	o.spec("reporting", function() {
+		o("reports per instance", function(done, timeout) {
+			timeout(100) // Waiting on clone
+
+			clone.run(function(results) {
+				o(typeof results).equals("object")
+				o("length" in results).equals(true)
+				o(results.length).equals(2)("Two results")
+
+				o("error" in results[0] && "pass" in results[0]).equals(true)("error and pass keys present in failing result")
+				o(!("error" in results[1]) && "pass" in results[1]).equals(true)("only pass key present in passing result")
+				o(results[0].pass).equals(false)("Test meant to fail has failed")
+				o(results[1].pass).equals(true)("Test meant to pass has passed")
+
+				done()
+			})
+		})
+		o("o.report() returns the number of failures", function () {
+			var log = console.log, error = console.error
+			console.log = o.spy()
+			console.error = o.spy()
+
+			function makeError(msg) {try{throw msg ? new Error(msg) : new Error} catch(e){return e}}
+			try {
+				var errCount = o.report([{pass: true}, {pass: true}])
+
+				o(errCount).equals(0)
+				o(console.log.callCount).equals(1)
+				o(console.error.callCount).equals(0)
+
+				errCount = o.report([
+					{pass: false, error: makeError("hey"), message: "hey"}
+				])
+
+				o(errCount).equals(1)
+				o(console.log.callCount).equals(2)
+				o(console.error.callCount).equals(1)
+
+				errCount = o.report([
+					{pass: false, error: makeError("hey"), message: "hey"},
+					{pass: true},
+					{pass: false, error: makeError("ho"), message: "ho"}
+				])
+				
+				o(errCount).equals(2)
+				o(console.log.callCount).equals(3)
+				o(console.error.callCount).equals(3)
+			} catch (e) {
+				o(1).equals(0)("Error while testing the reporter")
+			}
+
+			console.log = log
+			console.error = error
+		})
+	})
+}(o)
+
 o.spec("ospec", function() {
 	o.spec("sync", function() {
 		var a = 0, b = 0, illegalAssertionThrows = false
@@ -149,6 +220,18 @@ o.spec("ospec", function() {
 		})
 	})
 
+	o.spec("stack trace cleaner", function() {
+		o("handles line breaks", function() {
+			try {
+				throw new Error("line\nbreak")
+			} catch(error) {
+				var trace = o.cleanStackTrace(error)
+				o(trace).notEquals("break")
+				o(trace.includes("test-ospec.js")).equals(true)
+			}
+		})
+	})
+
 	o.spec("async promise", function() {
 		var a = 0, b = 0
 
@@ -188,8 +271,8 @@ o.spec("ospec", function() {
 			})
 		})
 
-		o("promise functions", async function() {
-			await wrapPromise(function() {
+		o("promise functions", function() {
+			return wrapPromise(function() {
 				o(a).equals(b)
 				o(a).equals(1)("a and b should be initialized")
 			})
diff --git a/package-lock.json b/package-lock.json
index 779147ad..8dd68afc 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -3797,15 +3797,6 @@
       "integrity": "sha1-Rb8dny19wJvtgfHDB8Qw5ouEz/4=",
       "dev": true
     },
-    "string_decoder": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz",
-      "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
-      "dev": true,
-      "requires": {
-        "safe-buffer": "5.1.1"
-      }
-    },
     "string-width": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz",
@@ -3817,6 +3808,15 @@
         "strip-ansi": "3.0.1"
       }
     },
+    "string_decoder": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz",
+      "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==",
+      "dev": true,
+      "requires": {
+        "safe-buffer": "5.1.1"
+      }
+    },
     "stringstream": {
       "version": "0.0.5",
       "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz",
diff --git a/render/render.js b/render/render.js
index 121083ca..a1478384 100644
--- a/render/render.js
+++ b/render/render.js
@@ -18,6 +18,24 @@ module.exports = function($window) {
 		return vnode.attrs && vnode.attrs.xmlns || nameSpace[vnode.tag]
 	}
 
+	//sanity check to discourage people from doing `vnode.state = ...`
+	function checkState(vnode, original) {
+		if (vnode.state !== original) throw new Error("`vnode.state` must not be modified")
+	}
+
+	//Note: the hook is passed as the `this` argument to allow proxying the
+	//arguments without requiring a full array allocation to do so. It also
+	//takes advantage of the fact the current `vnode` is the first argument in
+	//all lifecycle methods.
+	function callHook(vnode) {
+		var original = vnode.state
+		try {
+			return this.apply(original, arguments)
+		} finally {
+			checkState(vnode, original)
+		}
+	}
+
 	//create
 	function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) {
 		for (var i = start; i < end; i++) {
@@ -121,10 +139,9 @@ module.exports = function($window) {
 			sentinel.$$reentrantLock$$ = true
 			vnode.state = (vnode.tag.prototype != null && typeof vnode.tag.prototype.view === "function") ? new vnode.tag(vnode) : vnode.tag(vnode)
 		}
-		vnode._state = vnode.state
 		if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)
-		initLifecycle(vnode._state, vnode, hooks)
-		vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode))
+		initLifecycle(vnode.state, vnode, hooks)
+		vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
 		if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
 		sentinel.$$reentrantLock$$ = null
 	}
@@ -144,86 +161,212 @@ module.exports = function($window) {
 	}
 
 	//update
-	function updateNodes(parent, old, vnodes, recycling, hooks, nextSibling, ns) {
-		if (old === vnodes || old == null && vnodes == null) return
+	/**
+	 * @param {Element|Fragment} parent - the parent element
+	 * @param {Vnode[] | null} old - the list of vnodes of the last `render()` call for
+	 *                               this part of the tree
+	 * @param {Vnode[] | null} vnodes - as above, but for the current `render()` call.
+	 * @param {boolean} recyclingParent - was the parent vnode or one of its ancestor
+	 *                                    fetched from the recycling pool?
+	 * @param {Function[]} hooks - an accumulator of post-render hooks (oncreate/onupdate)
+	 * @param {Element | null} nextSibling - the next DOM node if we're dealing with a
+	 *                                       fragment that is not the last item in its
+	 *                                       parent
+	 * @param {'svg' | 'math' | String | null} ns) - the current XML namespace, if any
+	 * @returns void
+	 */
+	// This function diffs and patches lists of vnodes, both keyed and unkeyed.
+	//
+	// We will:
+	//
+	// 1. describe its general structure
+	// 2. focus on the diff algorithm optimizations
+	// 3. describe how the recycling pool meshes into this
+	// 4. discuss DOM node operations.
+
+	// ## Overview:
+	//
+	// The updateNodes() function:
+	// - deals with trivial cases
+	// - determines whether the lists are keyed or unkeyed
+	//   (Currently we look for the first pair of non-null nodes and deem the lists unkeyed
+	//   if both nodes are unkeyed. TODO (v2) We may later take advantage of the fact that
+	//   mixed diff is not supported and settle on the keyedness of the first vnode we find)
+	// - diffs them and patches the DOM if needed (that's the brunt of the code)
+	// - manages the leftovers: after diffing, are there:
+	//   - old nodes left to remove?
+	// 	 - new nodes to insert?
+	//   - nodes left in the recycling pool?
+	// 	 deal with them!
+	//
+	// The lists are only iterated over once, with an exception for the nodes in `old` that
+	// are visited in the fourth part of the diff and in the `removeNodes` loop.
+
+	// ## Diffing
+	//
+	// There's first a simple diff for unkeyed lists of equal length that eschews the pool.
+	//
+	// It is followed by a small section that activates the recycling pool if present, we'll
+	// ignore it for now.
+	//
+	// Then comes the main diff algorithm that is split in four parts (simplifying a bit).
+	//
+	// The first part goes through both lists top-down as long as the nodes at each level have
+	// the same key. This is always true for unkeyed lists that are entirely processed by this
+	// step.
+	//
+	// The second part deals with lists reversals, and traverses one list top-down and the other
+	// bottom-up (as long as the keys match).
+	//
+	// The third part goes through both lists bottom up as long as the keys match.
+	//
+	// The first and third sections allow us to deal efficiently with situations where one or
+	// more contiguous nodes were either inserted into, removed from or re-ordered in an otherwise
+	// sorted list. They may reduce the number of nodes to be processed in the fourth section.
+	//
+	// The fourth section does keyed diff for the situations not covered by the other three. It
+	// builds a {key: oldIndex} dictionary and uses it to find old nodes that match the keys of
+	// new ones.
+	// The nodes from the `old` array that have a match in the new `vnodes` one are marked as
+	// `vnode.skip: true`.
+	//
+	// If there are still nodes in the new `vnodes` array that haven't been matched to old ones,
+	// they are created.
+	// The range of old nodes that wasn't covered by the first three sections is passed to
+	// `removeNodes()`. Those nodes are removed unless marked as `.skip: true`.
+	//
+	// Then some pool business happens.
+	//
+	// It should be noted that the description of the four sections above is not perfect, because those
+	// parts are actually implemented as only two loops, one for the first two parts, and one for
+	// the other two. I'm not sure it wins us anything except maybe a few bytes of file size.
+
+	// ## The pool
+	//
+	// `old.pool` is an optional array that holds the vnodes that have been previously removed
+	// from the DOM at this level (provided they met the pool eligibility criteria).
+	//
+	// If the `old`, `old.pool` and `vnodes` meet some criteria described in `isRecyclable`, the
+	// elements of the pool are appended to the `old` array, which enables the reconciler to find
+	// them.
+	//
+	// While this is optimal for unkeyed diff and map-based keyed diff (the fourth diff part),
+	// that strategy clashes with the second and third parts of the main diff algo, because
+	// the end of the old list is now filled with the nodes of the pool.
+	//
+	// To determine if a vnode was brought back from the pool, we look at its position in the
+	// `old` array (see the various `oFromPool` definitions). That information is important
+	// in three circumstances:
+	// - If the old and the new vnodes are the same object (`===`), diff is not performed unless
+	//   the old node comes from the pool (since it must be recycled/re-created).
+	// - The value of `oFromPool` is passed as the `recycling` parameter of `updateNode()` (whether
+	//   the parent is being recycled is also factred in here)
+	// - It is used in the DOM node insertion logic (see below)
+	//
+	// At the very end of `updateNodes()`, the nodes in the pool that haven't been picked back
+	// are put in the new pool for the next render phase.
+	//
+	// The pool eligibility and `isRecyclable()` criteria are to be updated as part of #1675.
+
+	// ## DOM node operations
+	//
+	// In most cases `updateNode()` and `createNode()` perform the DOM operations. However,
+	// this is not the case if the node moved (second and fourth part of the diff algo), or
+	// if the node was brough back from the pool and both the old and new nodes have the same
+	// `.tag` value (when the `.tag` differ, `updateNode()` does the insertion).
+	//
+	// The fourth part of the diff currently inserts nodes unconditionally, leading to issues
+	// like #1791 and #1999. We need to be smarter about those situations where adjascent old
+	// nodes remain together in the new list in a way that isn't covered by parts one and
+	// three of the diff algo.
+
+	function updateNodes(parent, old, vnodes, recyclingParent, hooks, nextSibling, ns) {
+		if (old === vnodes && !recyclingParent || old == null && vnodes == null) return
 		else if (old == null) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns)
-		else if (vnodes == null) removeNodes(old, 0, old.length, vnodes)
+		else if (vnodes == null) removeNodes(old, 0, old.length, vnodes, recyclingParent)
 		else {
-			if (old.length === vnodes.length) {
-				var isUnkeyed = false
-				for (var i = 0; i < vnodes.length; i++) {
-					if (vnodes[i] != null && old[i] != null) {
-						isUnkeyed = vnodes[i].key == null && old[i].key == null
-						break
-					}
-				}
-				if (isUnkeyed) {
-					for (var i = 0; i < old.length; i++) {
-						if (old[i] === vnodes[i]) continue
-						else if (old[i] == null && vnodes[i] != null) createNode(parent, vnodes[i], hooks, ns, getNextSibling(old, i + 1, nextSibling))
-						else if (vnodes[i] == null) removeNodes(old, i, i + 1, vnodes)
-						else updateNode(parent, old[i], vnodes[i], hooks, getNextSibling(old, i + 1, nextSibling), recycling, ns)
-					}
-					return
+			var start = 0, commonLength = Math.min(old.length, vnodes.length), originalOldLength = old.length, hasPool = false, isUnkeyed = false
+			for(; start < commonLength; start++) {
+				if (old[start] != null && vnodes[start] != null) {
+					if (old[start].key == null && vnodes[start].key == null) isUnkeyed = true
+					break
 				}
 			}
-			recycling = recycling || isRecyclable(old, vnodes)
-			if (recycling) {
-				var pool = old.pool
+			if (isUnkeyed && originalOldLength === vnodes.length) {
+				for (start = 0; start < originalOldLength; start++) {
+					if (old[start] === vnodes[start] && !recyclingParent || old[start] == null && vnodes[start] == null) continue
+					else if (old[start] == null) createNode(parent, vnodes[start], hooks, ns, getNextSibling(old, start + 1, originalOldLength, nextSibling))
+					else if (vnodes[start] == null) removeNodes(old, start, start + 1, vnodes, recyclingParent)
+					else updateNode(parent, old[start], vnodes[start], hooks, getNextSibling(old, start + 1, originalOldLength, nextSibling), recyclingParent, ns)
+				}
+				return
+			}
+
+			if (isRecyclable(old, vnodes)) {
+				hasPool = true
 				old = old.concat(old.pool)
 			}
 
-			var oldStart = 0, start = 0, oldEnd = old.length - 1, end = vnodes.length - 1, map
+			var oldStart = start = 0, oldEnd = old.length - 1, end = vnodes.length - 1, map, o, v, oFromPool
+
 			while (oldEnd >= oldStart && end >= start) {
-				var o = old[oldStart], v = vnodes[start]
-				if (o === v && !recycling) oldStart++, start++
-				else if (o == null) oldStart++
-				else if (v == null) start++
-				else if (o.key === v.key) {
-					var shouldRecycle = (pool != null && oldStart >= old.length - pool.length) || ((pool == null) && recycling)
+				o = old[oldStart]
+				v = vnodes[start]
+				oFromPool = hasPool && oldStart >= originalOldLength
+				if (o === v && !oFromPool && !recyclingParent || o == null && v == null) oldStart++, start++
+				else if (o == null) {
+					if (isUnkeyed || v.key == null) {
+						createNode(parent, vnodes[start], hooks, ns, getNextSibling(old, ++start, originalOldLength, nextSibling))
+					}
+					oldStart++
+				} else if (v == null) {
+					if (isUnkeyed || o.key == null) {
+						removeNodes(old, start, start + 1, vnodes, recyclingParent)
+						oldStart++
+					}
+					start++
+				} else if (o.key === v.key) {
 					oldStart++, start++
-					updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), shouldRecycle, ns)
-					if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling)
-				}
-				else {
-					var o = old[oldEnd]
-					if (o === v && !recycling) oldEnd--, start++
+					updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+					if (oFromPool && o.tag === v.tag) insertNode(parent, toFragment(v), nextSibling)
+				} else {
+					o = old[oldEnd]
+					oFromPool = hasPool && oldEnd >= originalOldLength
+					if (o === v && !oFromPool && !recyclingParent) oldEnd--, start++
 					else if (o == null) oldEnd--
 					else if (v == null) start++
 					else if (o.key === v.key) {
-						var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling)
-						updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns)
-						if (recycling || start < end) insertNode(parent, toFragment(o), getNextSibling(old, oldStart, nextSibling))
+						updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+						if (oFromPool && o.tag === v.tag || start < end) insertNode(parent, toFragment(v), getNextSibling(old, oldStart, originalOldLength, nextSibling))
 						oldEnd--, start++
 					}
 					else break
 				}
 			}
 			while (oldEnd >= oldStart && end >= start) {
-				var o = old[oldEnd], v = vnodes[end]
-				if (o === v && !recycling) oldEnd--, end--
+				o = old[oldEnd]
+				v = vnodes[end]
+				oFromPool = hasPool && oldEnd >= originalOldLength
+				if (o === v && !oFromPool && !recyclingParent) oldEnd--, end--
 				else if (o == null) oldEnd--
 				else if (v == null) end--
 				else if (o.key === v.key) {
-					var shouldRecycle = (pool != null && oldEnd >= old.length - pool.length) || ((pool == null) && recycling)
-					updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), shouldRecycle, ns)
-					if (recycling && o.tag === v.tag) insertNode(parent, toFragment(o), nextSibling)
+					updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+					if (oFromPool && o.tag === v.tag) insertNode(parent, toFragment(v), nextSibling)
 					if (o.dom != null) nextSibling = o.dom
 					oldEnd--, end--
-				}
-				else {
+				} else {
 					if (!map) map = getKeyMap(old, oldEnd)
 					if (v != null) {
 						var oldIndex = map[v.key]
 						if (oldIndex != null) {
-							var movable = old[oldIndex]
-							var shouldRecycle = (pool != null && oldIndex >= old.length - pool.length) || ((pool == null) && recycling)
-							updateNode(parent, movable, v, hooks, getNextSibling(old, oldEnd + 1, nextSibling), recycling, ns)
-							insertNode(parent, toFragment(movable), nextSibling)
-							old[oldIndex].skip = true
-							if (movable.dom != null) nextSibling = movable.dom
-						}
-						else {
+							o = old[oldIndex]
+							oFromPool = hasPool && oldIndex >= originalOldLength
+							updateNode(parent, o, v, hooks, getNextSibling(old, oldEnd + 1, originalOldLength, nextSibling), oFromPool || recyclingParent, ns)
+							insertNode(parent, toFragment(v), nextSibling)
+							o.skip = true
+							if (o.dom != null) nextSibling = o.dom
+						} else {
 							var dom = createNode(parent, v, hooks, ns, nextSibling)
 							nextSibling = dom
 						}
@@ -233,14 +376,22 @@ module.exports = function($window) {
 				if (end < start) break
 			}
 			createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)
-			removeNodes(old, oldStart, oldEnd + 1, vnodes)
+			removeNodes(old, oldStart, Math.min(oldEnd + 1, originalOldLength), vnodes, recyclingParent)
+			if (hasPool) {
+				var limit = Math.max(oldStart, originalOldLength)
+				for (; oldEnd >= limit; oldEnd--) {
+					if (old[oldEnd].skip) old[oldEnd].skip = false
+					else addToPool(old[oldEnd], vnodes)
+				}
+			}
 		}
 	}
+	// when recycling, we're re-using an old DOM node, but firing the oninit/oncreate hooks
+	// instead of onbeforeupdate/onupdate.
 	function updateNode(parent, old, vnode, hooks, nextSibling, recycling, ns) {
 		var oldTag = old.tag, tag = vnode.tag
 		if (oldTag === tag) {
 			vnode.state = old.state
-			vnode._state = old._state
 			vnode.events = old.events
 			if (!recycling && shouldNotUpdate(vnode, old)) return
 			if (typeof oldTag === "string") {
@@ -261,7 +412,7 @@ module.exports = function($window) {
 			else updateComponent(parent, old, vnode, hooks, nextSibling, recycling, ns)
 		}
 		else {
-			removeNode(old, null)
+			removeNode(old, null, recycling)
 			createNode(parent, vnode, hooks, ns, nextSibling)
 		}
 	}
@@ -321,10 +472,10 @@ module.exports = function($window) {
 		if (recycling) {
 			initComponent(vnode, hooks)
 		} else {
-			vnode.instance = Vnode.normalize(vnode._state.view.call(vnode.state, vnode))
+			vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
 			if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
 			if (vnode.attrs != null) updateLifecycle(vnode.attrs, vnode, hooks)
-			updateLifecycle(vnode._state, vnode, hooks)
+			updateLifecycle(vnode.state, vnode, hooks)
 		}
 		if (vnode.instance != null) {
 			if (old.instance == null) createNode(parent, vnode.instance, hooks, ns, nextSibling)
@@ -333,7 +484,7 @@ module.exports = function($window) {
 			vnode.domSize = vnode.instance.domSize
 		}
 		else if (old.instance != null) {
-			removeNode(old.instance, null)
+			removeNode(old.instance, null, recycling)
 			vnode.dom = undefined
 			vnode.domSize = 0
 		}
@@ -377,15 +528,17 @@ module.exports = function($window) {
 		}
 		else return vnode.dom
 	}
-	function getNextSibling(vnodes, i, nextSibling) {
-		for (; i < vnodes.length; i++) {
+	// the vnodes array may hold items that come from the pool (after `limit`) they should
+	// be ignored
+	function getNextSibling(vnodes, i, limit, nextSibling) {
+		for (; i < limit; i++) {
 			if (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom
 		}
 		return nextSibling
 	}
 
 	function insertNode(parent, dom, nextSibling) {
-		if (nextSibling && nextSibling.parentNode) parent.insertBefore(dom, nextSibling)
+		if (nextSibling) parent.insertBefore(dom, nextSibling)
 		else parent.appendChild(dom)
 	}
 
@@ -399,35 +552,43 @@ module.exports = function($window) {
 	}
 
 	//remove
-	function removeNodes(vnodes, start, end, context) {
+	function removeNodes(vnodes, start, end, context, recycling) {
 		for (var i = start; i < end; i++) {
 			var vnode = vnodes[i]
 			if (vnode != null) {
 				if (vnode.skip) vnode.skip = false
-				else removeNode(vnode, context)
+				else removeNode(vnode, context, recycling)
 			}
 		}
 	}
-	function removeNode(vnode, context) {
+	// when a node is removed from a parent that's brought back from the pool, its hooks should
+	// not fire.
+	function removeNode(vnode, context, recycling) {
 		var expected = 1, called = 0
-		if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") {
-			var result = vnode.attrs.onbeforeremove.call(vnode.state, vnode)
-			if (result != null && typeof result.then === "function") {
-				expected++
-				result.then(continuation, continuation)
+		if (!recycling) {
+			var original = vnode.state
+			if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") {
+				var result = callHook.call(vnode.attrs.onbeforeremove, vnode)
+				if (result != null && typeof result.then === "function") {
+					expected++
+					result.then(continuation, continuation)
+				}
 			}
-		}
-		if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeremove === "function") {
-			var result = vnode._state.onbeforeremove.call(vnode.state, vnode)
-			if (result != null && typeof result.then === "function") {
-				expected++
-				result.then(continuation, continuation)
+			if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeremove === "function") {
+				var result = callHook.call(vnode.state.onbeforeremove, vnode)
+				if (result != null && typeof result.then === "function") {
+					expected++
+					result.then(continuation, continuation)
+				}
 			}
 		}
 		continuation()
 		function continuation() {
 			if (++called === expected) {
-				onremove(vnode)
+				if (!recycling) {
+					checkState(vnode, original)
+					onremove(vnode)
+				}
 				if (vnode.dom) {
 					var count = vnode.domSize || 1
 					if (count > 1) {
@@ -437,10 +598,7 @@ module.exports = function($window) {
 						}
 					}
 					removeNodeFromDOM(vnode.dom)
-					if (context != null && vnode.domSize == null && !hasIntegrationMethods(vnode.attrs) && typeof vnode.tag === "string") { //TODO test custom elements
-						if (!context.pool) context.pool = [vnode]
-						else context.pool.push(vnode)
-					}
+					addToPool(vnode, context)
 				}
 			}
 		}
@@ -449,10 +607,16 @@ module.exports = function($window) {
 		var parent = node.parentNode
 		if (parent != null) parent.removeChild(node)
 	}
+	function addToPool(vnode, context) {
+		if (context != null && vnode.domSize == null && !hasIntegrationMethods(vnode.attrs) && typeof vnode.tag === "string") { //TODO test custom elements
+			if (!context.pool) context.pool = [vnode]
+			else context.pool.push(vnode)
+		}
+	}
 	function onremove(vnode) {
-		if (vnode.attrs && typeof vnode.attrs.onremove === "function") vnode.attrs.onremove.call(vnode.state, vnode)
+		if (vnode.attrs && typeof vnode.attrs.onremove === "function") callHook.call(vnode.attrs.onremove, vnode)
 		if (typeof vnode.tag !== "string") {
-			if (typeof vnode._state.onremove === "function") vnode._state.onremove.call(vnode.state, vnode)
+			if (typeof vnode.state.onremove === "function") callHook.call(vnode.state.onremove, vnode)
 			if (vnode.instance != null) onremove(vnode.instance)
 		} else {
 			var children = vnode.children
@@ -533,7 +697,7 @@ module.exports = function($window) {
 		}
 	}
 	function isFormAttribute(vnode, attr) {
-		return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === $doc.activeElement
+		return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === $doc.activeElement || vnode.dom.parentNode === $doc.activeElement
 	}
 	function isLifecycleMethod(attr) {
 		return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate"
@@ -611,16 +775,20 @@ module.exports = function($window) {
 
 	//lifecycle
 	function initLifecycle(source, vnode, hooks) {
-		if (typeof source.oninit === "function") source.oninit.call(vnode.state, vnode)
-		if (typeof source.oncreate === "function") hooks.push(source.oncreate.bind(vnode.state, vnode))
+		if (typeof source.oninit === "function") callHook.call(source.oninit, vnode)
+		if (typeof source.oncreate === "function") hooks.push(callHook.bind(source.oncreate, vnode))
 	}
 	function updateLifecycle(source, vnode, hooks) {
-		if (typeof source.onupdate === "function") hooks.push(source.onupdate.bind(vnode.state, vnode))
+		if (typeof source.onupdate === "function") hooks.push(callHook.bind(source.onupdate, vnode))
 	}
 	function shouldNotUpdate(vnode, old) {
 		var forceVnodeUpdate, forceComponentUpdate
-		if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") forceVnodeUpdate = vnode.attrs.onbeforeupdate.call(vnode.state, vnode, old)
-		if (typeof vnode.tag !== "string" && typeof vnode._state.onbeforeupdate === "function") forceComponentUpdate = vnode._state.onbeforeupdate.call(vnode.state, vnode, old)
+		if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") {
+			forceVnodeUpdate = callHook.call(vnode.attrs.onbeforeupdate, vnode, old)
+		}
+		if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeupdate === "function") {
+			forceComponentUpdate = callHook.call(vnode.state.onbeforeupdate, vnode, old)
+		}
 		if (!(forceVnodeUpdate === undefined && forceComponentUpdate === undefined) && !forceVnodeUpdate && !forceComponentUpdate) {
 			vnode.dom = old.dom
 			vnode.domSize = old.domSize
@@ -642,9 +810,9 @@ module.exports = function($window) {
 		if (!Array.isArray(vnodes)) vnodes = [vnodes]
 		updateNodes(dom, dom.vnodes, Vnode.normalizeChildren(vnodes), false, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)
 		dom.vnodes = vnodes
-		for (var i = 0; i < hooks.length; i++) hooks[i]()
 		// document.activeElement can return null in IE https://developer.mozilla.org/en-US/docs/Web/API/Document/activeElement
 		if (active != null && $doc.activeElement !== active) active.focus()
+		for (var i = 0; i < hooks.length; i++) hooks[i]()
 	}
 
 	return {render: render, setEventCallback: setEventCallback}
diff --git a/render/tests/test-attributes.js b/render/tests/test-attributes.js
index d54ed9d4..62cb4196 100644
--- a/render/tests/test-attributes.js
+++ b/render/tests/test-attributes.js
@@ -462,6 +462,19 @@ o.spec("attributes", function() {
 				{tag:"option", attrs: {value: ""}}
 			]}
 		}
+		/* FIXME
+		   This incomplete test is meant for testing #1916.
+		   However it cannot be completed until #1978 is addressed
+		   which is a lack a working select.selected / option.selected
+		   attribute. Ask isiahmeadows.
+
+		o("render select options", function() {
+			var select = {tag: "select", selectedIndex: 0, children: [
+				{tag:"option", attrs: {value: "1", selected: ""}}
+			]}
+			render(root, select)
+		})
+		*/
 		o("can be set as text", function() {
 			var a = makeSelect()
 			var b = makeSelect("2")
diff --git a/render/tests/test-component.js b/render/tests/test-component.js
index c391ddd2..ea3d1624 100644
--- a/render/tests/test-component.js
+++ b/render/tests/test-component.js
@@ -764,97 +764,6 @@ o.spec("component", function() {
 						o(attrs[hook].callCount).equals(methods[hook].callCount)(hook)
 					})
 				})
-				o("lifecycle timing megatest (for a single component with the state overwritten)", function() {
-					var methods = {
-						view: o.spy(function(vnode) {
-							o(vnode.state).equals(1)
-							return ""
-						})
-					}
-					var attrs = {}
-					var hooks = [
-						"oninit", "oncreate", "onbeforeupdate",
-						"onupdate", "onbeforeremove", "onremove"
-					]
-					hooks.forEach(function(hook) {
-						// the `attrs` hooks are called before  the component ones
-						attrs[hook] = o.spy(function(vnode) {
-							o(vnode.state).equals(1)
-							o(attrs[hook].callCount).equals(methods[hook].callCount + 1)
-						})
-						methods[hook] = o.spy(function(vnode) {
-							o(vnode.state).equals(1)
-							o(attrs[hook].callCount).equals(methods[hook].callCount)
-						})
-					})
-
-					var attrsOninit = attrs.oninit
-					var methodsOninit = methods.oninit
-					attrs.oninit = o.spy(function(vnode){
-						vnode.state = 1
-						return attrsOninit.call(this, vnode)
-					})
-					methods.oninit = o.spy(function(vnode){
-						vnode.state = 1
-						return methodsOninit.call(this, vnode)
-					})
-
-					var component = createComponent(methods)
-
-					o(methods.view.callCount).equals(0)
-					o(methods.oninit.callCount).equals(0)
-					o(methods.oncreate.callCount).equals(0)
-					o(methods.onbeforeupdate.callCount).equals(0)
-					o(methods.onupdate.callCount).equals(0)
-					o(methods.onbeforeremove.callCount).equals(0)
-					o(methods.onremove.callCount).equals(0)
-
-					hooks.forEach(function(hook) {
-						o(attrs[hook].callCount).equals(methods[hook].callCount)(hook)
-					})
-
-					render(root, [{tag: component, attrs: attrs}])
-
-					o(methods.view.callCount).equals(1)
-					o(methods.oninit.callCount).equals(1)
-					o(methods.oncreate.callCount).equals(1)
-					o(methods.onbeforeupdate.callCount).equals(0)
-					o(methods.onupdate.callCount).equals(0)
-					o(methods.onbeforeremove.callCount).equals(0)
-					o(methods.onremove.callCount).equals(0)
-
-					hooks.forEach(function(hook) {
-						o(attrs[hook].callCount).equals(methods[hook].callCount)(hook)
-					})
-
-					render(root, [{tag: component, attrs: attrs}])
-
-					o(methods.view.callCount).equals(2)
-					o(methods.oninit.callCount).equals(1)
-					o(methods.oncreate.callCount).equals(1)
-					o(methods.onbeforeupdate.callCount).equals(1)
-					o(methods.onupdate.callCount).equals(1)
-					o(methods.onbeforeremove.callCount).equals(0)
-					o(methods.onremove.callCount).equals(0)
-
-					hooks.forEach(function(hook) {
-						o(attrs[hook].callCount).equals(methods[hook].callCount)(hook)
-					})
-
-					render(root, [])
-
-					o(methods.view.callCount).equals(2)
-					o(methods.oninit.callCount).equals(1)
-					o(methods.oncreate.callCount).equals(1)
-					o(methods.onbeforeupdate.callCount).equals(1)
-					o(methods.onupdate.callCount).equals(1)
-					o(methods.onbeforeremove.callCount).equals(1)
-					o(methods.onremove.callCount).equals(1)
-
-					hooks.forEach(function(hook) {
-						o(attrs[hook].callCount).equals(methods[hook].callCount)(hook)
-					})
-				})
 				o("hook state and arguments validation", function(){
 					var methods = {
 						view: o.spy(function(vnode) {
diff --git a/render/tests/test-input.js b/render/tests/test-input.js
index d61bad54..1f9a24d7 100644
--- a/render/tests/test-input.js
+++ b/render/tests/test-input.js
@@ -30,6 +30,16 @@ o.spec("form inputs", function() {
 			o($window.document.activeElement).equals(input.dom)
 		})
 
+		o("maintains focus when changed manually in hook", function() {
+			var input = {tag: "input", attrs: {oncreate: function() {
+				input.dom.focus();
+			}}};
+
+			render(root, [input])
+
+			o($window.document.activeElement).equals(input.dom)
+		})
+
 		o("syncs input value if DOM value differs from vdom value", function() {
 			var input = {tag: "input", attrs: {value: "aaa", oninput: function() {}}}
 			var updated = {tag: "input", attrs: {value: "aaa", oninput: function() {}}}
diff --git a/render/tests/test-onbeforeremove.js b/render/tests/test-onbeforeremove.js
index 0e83d4a0..834f7510 100644
--- a/render/tests/test-onbeforeremove.js
+++ b/render/tests/test-onbeforeremove.js
@@ -36,10 +36,7 @@ o.spec("onbeforeremove", function() {
 		o(update.callCount).equals(0)
 	})
 	o("calls onbeforeremove when removing element", function(done) {
-		var vnode = {tag: "div", attrs: {
-			oninit: function() {vnode.state = {}},
-			onbeforeremove: remove
-		}}
+		var vnode = {tag: "div", attrs: {onbeforeremove: remove}}
 
 		render(root, [vnode])
 		render(root, [])
@@ -47,6 +44,7 @@ o.spec("onbeforeremove", function() {
 		function remove(node) {
 			o(node).equals(vnode)
 			o(this).equals(vnode.state)
+			o(this != null && typeof this === "object").equals(true)
 			o(root.childNodes.length).equals(1)
 			o(root.firstChild).equals(vnode.dom)
 
diff --git a/render/tests/test-oninit.js b/render/tests/test-oninit.js
index 4d94cae4..f6ffb873 100644
--- a/render/tests/test-oninit.js
+++ b/render/tests/test-oninit.js
@@ -199,4 +199,27 @@ o.spec("oninit", function() {
 		o(vnode.dom.oninit).equals(undefined)
 		o(vnode.dom.attributes["oninit"]).equals(undefined)
 	})
+	
+	o("No spurious oninit calls in mapped keyed diff when the pool is involved (#1992)", function () {
+		var oninit1 = o.spy()
+		var oninit2 = o.spy()
+		var oninit3 = o.spy()
+
+		render(root, [
+			{tag: "p", key: 1, attrs: {oninit: oninit1}},
+			{tag: "p", key: 2, attrs: {oninit: oninit2}},
+			{tag: "p", key: 3, attrs: {oninit: oninit3}},
+		])
+		render(root, [
+			{tag: "p", key: 1, attrs: {oninit: oninit1}},
+			{tag: "p", key: 3, attrs: {oninit: oninit3}},
+		])
+		render(root, [
+			{tag: "p", key: 3, attrs: {oninit: oninit3}},
+		])
+
+		o(oninit1.callCount).equals(1)
+		o(oninit2.callCount).equals(1)
+		o(oninit3.callCount).equals(1)
+	})
 })
diff --git a/render/tests/test-onremove.js b/render/tests/test-onremove.js
index f509e704..5ab20caf 100644
--- a/render/tests/test-onremove.js
+++ b/render/tests/test-onremove.js
@@ -101,6 +101,7 @@ o.spec("onremove", function() {
 		render(root, temp)
 		render(root, updated)
 
+		o(vnodes[0].dom).equals(updated[0].dom)
 		o(remove.callCount).equals(1)
 	})
 	o("does not recycle when there's an onremove", function() {
@@ -132,7 +133,7 @@ o.spec("onremove", function() {
 				})
 				render(root, {tag: comp})
 				render(root, null)
-				
+
 				o(spy.callCount).equals(1)
 			})
 			o("calls onremove on nested component child", function() {
@@ -148,7 +149,7 @@ o.spec("onremove", function() {
 				})
 				render(root, {tag: comp})
 				render(root, null)
-				
+
 				o(spy.callCount).equals(1)
 			})
 			o("doesn't call onremove on children when the corresponding view returns null (after removing the parent)", function() {
@@ -191,6 +192,28 @@ o.spec("onremove", function() {
 				o(spy.callCount).equals(0)
 				o(threw).equals(false)
 			})
+			o("onremove doesn't fire on nodes that go from pool to pool (#1990)", function() {
+				var onremove = o.spy();
+
+				render(root, [m("div", m("div")), m("div", m("div", {onremove: onremove}))]);
+				render(root, [m("div", m("div"))]);
+				render(root, []);
+
+				o(onremove.callCount).equals(1)
+			})
+			o("doesn't fire when removing the children of a node that's brought back from the pool (#1991 part 2)", function() {
+				var onremove = o.spy()
+				var vnode = {tag: "div", key: 1, children: [{tag: "div", attrs: {onremove: onremove}}]}
+				var temp = {tag: "div", key: 2}
+				var updated = {tag: "div", key: 1, children: [{tag: "p"}]}
+
+				render(root, [vnode])
+				render(root, [temp])
+				render(root, [updated])
+
+				o(vnode.dom).equals(updated.dom)
+				o(onremove.callCount).equals(1)
+			})
 		})
 	})
 })
\ No newline at end of file
diff --git a/render/tests/test-updateNodes.js b/render/tests/test-updateNodes.js
index fa5231ea..65d81916 100644
--- a/render/tests/test-updateNodes.js
+++ b/render/tests/test-updateNodes.js
@@ -839,6 +839,19 @@ o.spec("updateNodes", function() {
 		o(root.childNodes[0].nodeName).equals("A")
 		o(root.childNodes[1].nodeName).equals("B")
 	})
+	o("onremove doesn't fire from nodes in the pool (#1990)", function () {
+		var onremove = o.spy()
+		render(root, [
+			{tag: "div", children: [{tag: "div", attrs: {onremove: onremove}}]},
+			{tag: "div", children: [{tag: "div", attrs: {onremove: onremove}}]}
+		])
+		render(root, [
+			{tag: "div", children: [{tag: "div", attrs: {onremove: onremove}}]}
+		])
+		render(root,[])
+
+		o(onremove.callCount).equals(2)
+	})
 	o("cached, non-keyed nodes skip diff", function () {
 		var onupdate = o.spy();
 		var cached = {tag:"a", attrs:{onupdate: onupdate}}
@@ -857,6 +870,72 @@ o.spec("updateNodes", function() {
 
 		o(onupdate.callCount).equals(0)
 	})
+	o("keyed cached elements are re-initialized when brought back from the pool (#2003)", function () {
+		var onupdate = o.spy()
+		var oncreate = o.spy()
+		var cached = {
+			tag: "B", key: 1, children: [
+				{tag: "A", attrs: {oncreate: oncreate, onupdate: onupdate}, text: "A"}
+			]
+		}
+		render(root, [{tag: "div", children: [cached]}])
+		render(root, [])
+		render(root, [{tag: "div", children: [cached]}])
+
+		o(oncreate.callCount).equals(2)
+		o(onupdate.callCount).equals(0)
+	})
+
+	o("unkeyed cached elements are re-initialized when brought back from the pool (#2003)", function () {
+		var onupdate = o.spy()
+		var oncreate = o.spy()
+		var cached = {
+			tag: "B", children: [
+				{tag: "A", attrs: {oncreate: oncreate, onupdate: onupdate}, text: "A"}
+			]
+		}
+		render(root, [{tag: "div", children: [cached]}])
+		render(root, [])
+		render(root, [{tag: "div", children: [cached]}])
+
+		o(oncreate.callCount).equals(2)
+		o(onupdate.callCount).equals(0)
+	})
+
+	o("keyed cached elements are re-initialized when brought back from nested pools (#2003)", function () {
+		var onupdate = o.spy()
+		var oncreate = o.spy()
+		var cached = {
+			tag: "B", key: 1, children: [
+				{tag: "A", attrs: {oncreate: oncreate, onupdate: onupdate}, text: "A"}
+			]
+		}
+		render(root, [{tag: "div", children: [cached]}])
+		render(root, [{tag: "div", children: []}])
+		render(root, [])
+		render(root, [{tag: "div", children: [cached]}])
+
+		o(oncreate.callCount).equals(2)
+		o(onupdate.callCount).equals(0)
+	})
+
+	o("unkeyed cached elements are re-initialized when brought back from nested pools (#2003)", function () {
+		var onupdate = o.spy()
+		var oncreate = o.spy()
+		var cached = {
+			tag: "B", children: [
+				{tag: "A", attrs: {oncreate: oncreate, onupdate: onupdate}, text: "A"}
+			]
+		}
+		render(root, [{tag: "div", children: [cached]}])
+		render(root, [{tag: "div", children: []}])
+		render(root, [])
+		render(root, [{tag: "div", children: [cached]}])
+
+		o(oncreate.callCount).equals(2)
+		o(onupdate.callCount).equals(0)
+	})
+
 	o("null stays in place", function() {
 		var create = o.spy()
 		var update = o.spy()
@@ -904,6 +983,62 @@ o.spec("updateNodes", function() {
 
 		o(vnode.dom).notEquals(updated.dom)
 	})
+	o("don't add back elements from fragments that are restored from the pool #1991", function() {
+		render(root, [
+			{tag: "[", children: []},
+			{tag: "[", children: []}
+		])
+		render(root, [
+			{tag: "[", children: []},
+			{tag: "[", children: [{tag: "div"}]}
+		])
+		render(root, [
+			{tag: "[", children: [null]}
+		])
+		render(root, [
+			{tag: "[", children: []},
+			{tag: "[", children: []}
+		])
+
+		o(root.childNodes.length).equals(0)
+	})
+	o("don't add back elements from fragments that are being removed #1991", function() {
+		render(root, [
+			{tag: "[", children: []},
+			{tag: "p"},
+		])
+		render(root, [
+			{tag: "[", children: [{tag: "div", text: 5}]}
+		])
+		render(root, [
+			{tag: "[", children: []},
+			{tag: "[", children: []}
+		])
+
+		o(root.childNodes.length).equals(0)
+	})
+	o("handles null values in unkeyed lists of different length (#2003)", function() {
+		var oncreate = o.spy();
+		var onremove = o.spy();
+		var onupdate = o.spy();
+		function attrs() {
+			return {oncreate: oncreate, onremove: onremove, onupdate: onupdate}
+		}
+
+		render(root, [{tag: "div", attrs: attrs()}, null]);
+		render(root, [null, {tag: "div", attrs: attrs()}, null]);
+
+		o(oncreate.callCount).equals(2)
+		o(onremove.callCount).equals(1)
+		o(onupdate.callCount).equals(0)
+	})
+	o("don't fetch the nextSibling from the pool", function() {
+		render(root, [{tag: "[", children: [{tag: "div", key: 1}, {tag: "div", key: 2}]}, {tag: "p"}])
+		render(root, [{tag: "[", children: []}, {tag: "p"}])
+		render(root, [{tag: "[", children: [{tag: "div", key: 2}, {tag: "div", key: 1}]}, {tag: "p"}])
+
+		o([].map.call(root.childNodes, function(el) {return el.nodeName})).deepEquals(["DIV", "DIV", "P"])
+	})
 	components.forEach(function(cmp){
 		o.spec(cmp.kind, function(){
 			var createComponent = cmp.create
diff --git a/render/vnode.js b/render/vnode.js
index ce137703..13ed393f 100644
--- a/render/vnode.js
+++ b/render/vnode.js
@@ -1,7 +1,7 @@
 "use strict"
 
 function Vnode(tag, key, attrs, children, text, dom) {
-	return {tag: tag, key: key, attrs: attrs, children: children, text: text, dom: dom, domSize: undefined, state: undefined, _state: undefined, events: undefined, instance: undefined, skip: false}
+	return {tag: tag, key: key, attrs: attrs, children: children, text: text, dom: dom, domSize: undefined, state: undefined, events: undefined, instance: undefined, skip: false}
 }
 Vnode.normalize = function(node) {
 	if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
diff --git a/request/request.js b/request/request.js
index 7e4ec744..8424f889 100644
--- a/request/request.js
+++ b/request/request.js
@@ -75,6 +75,8 @@ module.exports = function($window, Promise) {
 			}
 			if (args.withCredentials) xhr.withCredentials = args.withCredentials
 
+			if (args.timeout) xhr.timeout = args.timeout
+
 			for (var key in args.headers) if ({}.hasOwnProperty.call(args.headers, key)) {
 				xhr.setRequestHeader(key, args.headers[key])
 			}
@@ -88,7 +90,7 @@ module.exports = function($window, Promise) {
 				if (xhr.readyState === 4) {
 					try {
 						var response = (args.extract !== extract) ? args.extract(xhr, args) : args.deserialize(args.extract(xhr, args))
-						if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || FILE_PROTOCOL_REGEX.test(args.url)) {
+						if (args.extract !== extract || (xhr.status >= 200 && xhr.status < 300) || xhr.status === 304 || FILE_PROTOCOL_REGEX.test(args.url)) {
 							resolve(cast(args.type, response))
 						}
 						else {
diff --git a/request/tests/test-request.js b/request/tests/test-request.js
index 94e7e172..52f840ef 100644
--- a/request/tests/test-request.js
+++ b/request/tests/test-request.js
@@ -230,7 +230,7 @@ o.spec("xhr", function() {
 				}
 			})
 			xhr({method: "GET", url: "/item", deserialize: deserialize}).then(function(data) {
-				o(data).equals('{"test":123}')
+				o(data).equals("{\"test\":123}")
 			}).then(done)
 		})
 		o("deserialize parameter works in POST", function(done) {
@@ -244,7 +244,7 @@ o.spec("xhr", function() {
 				}
 			})
 			xhr({method: "POST", url: "/item", deserialize: deserialize}).then(function(data) {
-				o(data).equals('{"test":123}')
+				o(data).equals("{\"test\":123}")
 			}).then(done)
 		})
 		o("extract parameter works in GET", function(done) {
@@ -258,7 +258,7 @@ o.spec("xhr", function() {
 				}
 			})
 			xhr({method: "GET", url: "/item", extract: extract}).then(function(data) {
-				o(data).equals('{"test":123}')
+				o(data).equals("{\"test\":123}")
 			}).then(done)
 		})
 		o("extract parameter works in POST", function(done) {
@@ -272,7 +272,7 @@ o.spec("xhr", function() {
 				}
 			})
 			xhr({method: "POST", url: "/item", extract: extract}).then(function(data) {
-				o(data).equals('{"test":123}')
+				o(data).equals("{\"test\":123}")
 			}).then(done)
 		})
 		o("ignores deserialize if extract is defined", function(done) {
@@ -435,6 +435,20 @@ o.spec("xhr", function() {
 				done()
 			})
 		})
+		o("set timeout to xhr instance", function() {
+			mock.$defineRoutes({
+				"GET /item": function() {
+					return {status: 200, responseText: ""}
+				}
+			})
+			return xhr({
+				method: "GET", url: "/item",
+				timeout: 42,
+				config: function(xhr) {
+					o(xhr.timeout).equals(42)
+				}
+			})
+		})
 		/*o("data maintains after interpolate", function() {
 			mock.$defineRoutes({
 				"PUT /items/:x": function() {
@@ -519,5 +533,35 @@ o.spec("xhr", function() {
 				o(e instanceof Error).equals(true)
 			}).then(done)
 		})
+		o("does not reject on status error code when extract provided", function(done) {
+			mock.$defineRoutes({
+				"GET /item": function() {
+					return {status: 500, responseText: JSON.stringify({message: "error"})}
+				}
+			})
+			xhr({
+				method: "GET", url: "/item",
+				extract: function(xhr) {return JSON.parse(xhr.responseText)}
+			}).then(function(data) {
+				o(data.message).equals("error")
+				done()
+			})
+		})
+		o("rejects on error in extract", function(done) {
+			mock.$defineRoutes({
+				"GET /item": function() {
+					return {status: 200, responseText: JSON.stringify({a: 1})}
+				}
+			})
+			xhr({
+				method: "GET", url: "/item",
+				extract: function() {throw new Error("error")}
+			}).catch(function(e) {
+				o(e instanceof Error).equals(true)
+				o(e.message).equals("error")
+			}).then(function() {
+				done()
+			})
+		})
 	})
 })
diff --git a/test-utils/domMock.js b/test-utils/domMock.js
index b8f5d1a3..a4c7c598 100644
--- a/test-utils/domMock.js
+++ b/test-utils/domMock.js
@@ -37,6 +37,30 @@ module.exports = function(options) {
 	function isModernEvent(type) {
 		return type === "transitionstart" || type === "transitionend" || type === "animationstart" || type === "animationend"
 	}
+	function dispatchEvent(e) {
+		var stopped = false
+		e.stopImmediatePropagation = function() {
+			e.stopPropagation()
+			stopped = true
+		}
+		e.currentTarget = this
+		if (this._events[e.type] != null) {
+			for (var i = 0; i < this._events[e.type].handlers.length; i++) {
+				var useCapture = this._events[e.type].options[i].capture
+				if (useCapture && e.eventPhase < 3 || !useCapture && e.eventPhase > 1) {
+					var handler = this._events[e.type].handlers[i]
+					if (typeof handler === "function") try {handler.call(this, e)} catch(e) {setTimeout(function(){throw e})}
+					else try {handler.handleEvent(e)} catch(e) {setTimeout(function(){throw e})}
+					if (stopped) return
+				}
+			}
+		}
+		// this is inaccurate. Normally the event fires in definition order, including legacy events
+		// this would require getters/setters for each of them though and we haven't gotten around to
+		// adding them since it would be at a high perf cost or would entail some heavy refactoring of
+		// the mocks (prototypes instead of closures).
+		if (e.eventPhase > 1 && typeof this["on" + e.type] === "function" && !isModernEvent(e.type)) try {this["on" + e.type](e)} catch(e) {setTimeout(function(){throw e})}
+	}
 	function appendChild(child) {
 		var ancestor = this
 		while (ancestor !== child && ancestor !== null) ancestor = ancestor.parentNode
@@ -260,35 +284,99 @@ module.exports = function(options) {
 						else this.setAttribute("class", value)
 					},
 					focus: function() {activeElement = this},
-					addEventListener: function(type, callback) {
-						if (events[type] == null) events[type] = [callback]
-						else events[type].push(callback)
+					addEventListener: function(type, handler, options) {
+						if (arguments.length > 2) {
+							if (typeof options === "object" && options != null) throw new TypeError("NYI: addEventListener options")
+							else if (typeof options !== "boolean") throw new TypeError("boolean expected for useCapture")
+							else options = {capture: options}
+						} else {
+							options = {capture: false}
+						}
+						if (events[type] == null) events[type] = {handlers: [handler], options: [options]}
+						else {
+							var found = false
+							for (var i = 0; i < events[type].handlers.length; i++) {
+								if (events[type].handlers[i] === handler && events[type].options[i].capture === options.capture) {
+									found = true
+									break
+								}
+							}
+							if (!found) {
+								events[type].handlers.push(handler)
+								events[type].options.push(options)
+							}
+						}
 					},
-					removeEventListener: function(type, callback) {
+					removeEventListener: function(type, handler, options) {
+						if (arguments.length > 2) {
+							if (typeof options === "object" && options != null) throw new TypeError("NYI: addEventListener options")
+							else if (typeof options !== "boolean") throw new TypeError("boolean expected for useCapture")
+							else options = {capture: options}
+						} else {
+							options = {capture: false}
+						}
 						if (events[type] != null) {
-							var index = events[type].indexOf(callback)
-							if (index > -1) events[type].splice(index, 1)
+							for (var i = 0; i < events[type].handlers.length; i++) {
+								if (events[type].handlers[i] === handler && events[type].options[i].capture === options.capture) {
+									events[type].handlers.splice(i, 1)
+									events[type].options.splice(i, 1)
+									break;
+								}
+							}
 						}
 					},
 					dispatchEvent: function(e) {
-						if (this.nodeName === "INPUT" && this.attributes["type"] != null && this.attributes["type"].value === "checkbox" && e.type === "click") {
-							this.checked = !this.checked
+						var parents = []
+						if (this.parentNode != null) {
+							var parent = this.parentNode
+							do {
+								parents.push(parent)
+								parent = parent.parentNode
+							} while (parent != null)
 						}
-
 						e.target = this
-						if (events[e.type] != null) {
-							for (var i = 0; i < events[e.type].length; i++) {
-								var handler = events[e.type][i]
-								if (typeof handler === "function") handler.call(this, e)
-								else handler.handleEvent(e)
+						var prevented = false
+						e.preventDefault = function() {
+							prevented = true
+						}
+						var stopped = false
+						e.stopPropagation = function() {
+							stopped = true
+						}
+						e.eventPhase = 1
+						try {
+							for (var i = parents.length - 1; 0 <= i; i--) {
+								dispatchEvent.call(parents[i], e)
+								if (stopped) {
+									return
+								}
+							}
+							e.eventPhase = 2
+							dispatchEvent.call(this, e)
+							if (stopped) {
+								return
+							}
+							e.eventPhase = 3
+							for (var i = 0; i < parents.length; i++) {
+								dispatchEvent.call(parents[i], e)
+								if (stopped) {
+									return
+								}
+							}
+						} catch(e) {
+							throw e
+						} finally {
+							e.eventPhase = 0
+							if (!prevented) {
+								if (this.nodeName === "INPUT" && this.attributes["type"] != null && this.attributes["type"].value === "checkbox" && e.type === "click") {
+									this.checked = !this.checked
+								}
 							}
 						}
-						e.preventDefault = function() {
-							// TODO: should this do something?
-						}
-						if (typeof this["on" + e.type] === "function" && !isModernEvent(e.type)) this["on" + e.type](e)
+
 					},
 					onclick: null,
+					_events: events
 				}
 
 				if (element.nodeName === "A") {
@@ -515,7 +603,8 @@ module.exports = function(options) {
 			},
 			createEvent: function() {
 				return {
-					initEvent: function(type) {this.type = type},
+					eventPhase: 0,
+					initEvent: function(type) {this.type = type}
 				}
 			},
 			get activeElement() {return activeElement},
diff --git a/test-utils/tests/test-domMock.js b/test-utils/tests/test-domMock.js
index 3e4a9567..f05d24c9 100644
--- a/test-utils/tests/test-domMock.js
+++ b/test-utils/tests/test-domMock.js
@@ -611,13 +611,57 @@ o.spec("domMock", function() {
 				o(spy.args[0].type).equals("click")
 				o(spy.args[0].target).equals(div)
 			})
-			o("removeEventListener works", function(done) {
+			o("removeEventListener works (bubbling phase)", function() {
 				div.addEventListener("click", spy, false)
 				div.removeEventListener("click", spy, false)
 				div.dispatchEvent(e)
 
 				o(spy.callCount).equals(0)
-				done()
+			})
+			o("removeEventListener works (capture phase)", function() {
+				div.addEventListener("click", spy, true)
+				div.removeEventListener("click", spy, true)
+				div.dispatchEvent(e)
+
+				o(spy.callCount).equals(0)
+			})
+			o("removeEventListener is selective (bubbling phase)", function() {
+				var other = o.spy()
+				div.addEventListener("click", spy, false)
+				div.addEventListener("click", other, false)
+				div.removeEventListener("click", spy, false)
+				div.dispatchEvent(e)
+
+				o(spy.callCount).equals(0)
+				o(other.callCount).equals(1)
+			})
+			o("removeEventListener is selective (capture phase)", function() {
+				var other = o.spy()
+				div.addEventListener("click", spy, true)
+				div.addEventListener("click", other, true)
+				div.removeEventListener("click", spy, true)
+				div.dispatchEvent(e)
+
+				o(spy.callCount).equals(0)
+				o(other.callCount).equals(1)
+			})
+			o("removeEventListener only removes the handler related to a given phase (1/2)", function() {
+				spy = o.spy(function(e) {o(e.eventPhase).equals(3)})
+				$document.body.addEventListener("click", spy, true)
+				$document.body.addEventListener("click", spy, false)
+				$document.body.removeEventListener("click", spy, true)
+				div.dispatchEvent(e)
+
+				o(spy.callCount).equals(1)
+			})
+			o("removeEventListener only removes the handler related to a given phase (2/2)", function() {
+				spy = o.spy(function(e) {o(e.eventPhase).equals(1)})
+				$document.body.addEventListener("click", spy, true)
+				$document.body.addEventListener("click", spy, false)
+				$document.body.removeEventListener("click", spy, false)
+				div.dispatchEvent(e)
+
+				o(spy.callCount).equals(1)
 			})
 			o("click fires onclick", function() {
 				div.onclick = spy
@@ -655,6 +699,488 @@ o.spec("domMock", function() {
 				done()
 			})
 		})
+		o.spec("capture and bubbling phases", function() {
+			var div, e
+			o.beforeEach(function() {
+				div = $document.createElement("div")
+				e = $document.createEvent("MouseEvents")
+				e.initEvent("click", true, true)
+
+				$document.body.appendChild(div)
+			})
+			o.afterEach(function() {
+				$document.body.removeChild(div)
+			})
+			o("capture and bubbling events both fire on the target in the order they were defined, regardless of the phase", function () {
+				var sequence = []
+				var capture = o.spy(function(ev){
+					sequence.push("capture")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(2)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals(div)
+				})
+				var bubble = o.spy(function(ev){
+					sequence.push("bubble")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(2)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals(div)
+				})
+
+				div.addEventListener("click", bubble, false)
+				div.addEventListener("click", capture, true)
+				div.dispatchEvent(e)
+
+				o(capture.callCount).equals(1)
+				o(bubble.callCount).equals(1)
+				o(sequence).deepEquals(["bubble", "capture"])
+			})
+			o("capture and bubbling events both fire on the parent", function () {
+				var sequence = []
+				var capture = o.spy(function(ev){
+					sequence.push("capture")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(1)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals($document.body)
+				})
+				var bubble = o.spy(function(ev){
+					sequence.push("bubble")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(3)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals($document.body)
+				})
+
+				$document.body.addEventListener("click", bubble, false)
+				$document.body.addEventListener("click", capture, true)
+				div.dispatchEvent(e)
+
+				o(capture.callCount).equals(1)
+				o(bubble.callCount).equals(1)
+				o(sequence).deepEquals(["capture", "bubble"])
+			})
+			o("useCapture defaults to false", function () {
+				var sequence = []
+				var parent = o.spy(function(ev){
+					sequence.push("parent")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(3)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals($document.body)
+				})
+				var target = o.spy(function(ev){
+					sequence.push("target")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(2)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals(div)
+				})
+
+				$document.body.addEventListener("click", parent)
+				div.addEventListener("click", target)
+				div.dispatchEvent(e)
+
+				o(parent.callCount).equals(1)
+				o(target.callCount).equals(1)
+				o(sequence).deepEquals(["target", "parent"])
+			})
+			o("legacy handlers fire on the bubbling phase", function () {
+				var sequence = []
+				var parent = o.spy(function(ev){
+					sequence.push("parent")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(3)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals($document.body)
+				})
+				var target = o.spy(function(ev){
+					sequence.push("target")
+
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(2)
+					o(ev.target).equals(div)
+					o(ev.currentTarget).equals(div)
+				})
+
+				$document.body.addEventListener("click", parent)
+				$document.body.onclick = parent
+				div.addEventListener("click", target)
+				div.dispatchEvent(e)
+
+				o(parent.callCount).equals(2)
+				o(target.callCount).equals(1)
+				o(sequence).deepEquals(["target", "parent", "parent"])
+			})
+			o("events do not propagate to child nodes", function() {
+				var target = o.spy(function(ev){
+					o(ev).equals(e)
+					o(ev.eventPhase).equals(2)
+					o(ev.target).equals($document.body)
+					o(ev.currentTarget).equals($document.body)
+				})
+				var child = o.spy(function(){
+				})
+
+				$document.body.addEventListener("click", target)
+				div.addEventListener("click", child)
+				$document.body.dispatchEvent(e)
+
+				o(target.callCount).equals(1)
+				o(child.callCount).equals(0)
+			})
+			o("e.stopPropagation 1/6", function () {
+				var capParent = o.spy(function(e){e.stopPropagation()})
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(0)
+				o(bubTarget.callCount).equals(0)
+				o(legacyTarget.callCount).equals(0)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopPropagation 2/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy(function(e){e.stopPropagation()})
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+
+			o("e.stopPropagation 3/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy(function(e){e.stopPropagation()})
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopPropagation 4/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy(function(e){e.stopPropagation()})
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopPropagation 5/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy(function(e){e.stopPropagation()})
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(1)
+				o(legacyParent.callCount).equals(1)
+			})
+			o("e.stopPropagation 6/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy(function(e){e.stopPropagation()})
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(1)
+				o(legacyParent.callCount).equals(1)
+			})
+			o("e.stopImmediatePropagation 1/6", function () {
+				var capParent = o.spy(function(e){e.stopImmediatePropagation()})
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(0)
+				o(bubTarget.callCount).equals(0)
+				o(legacyTarget.callCount).equals(0)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopImmediatePropagation 2/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy(function(e){e.stopImmediatePropagation()})
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(0)
+				o(legacyTarget.callCount).equals(0)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+
+			o("e.stopImmediatePropagation 3/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy(function(e){e.stopImmediatePropagation()})
+				var legacyTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(0)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopImmediatePropagation 4/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy(function(e){e.stopImmediatePropagation()})
+				var bubParent = o.spy()
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(0)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopImmediatePropagation 5/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var bubTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubParent = o.spy(function(e){e.stopImmediatePropagation()})
+				var legacyParent = o.spy()
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(1)
+				o(legacyParent.callCount).equals(0)
+			})
+			o("e.stopImmediatePropagation 6/6", function () {
+				var capParent = o.spy()
+				var capTarget = o.spy()
+				var legacyTarget = o.spy()
+				var bubTarget = o.spy()
+				var bubParent = o.spy()
+				var legacyParent = o.spy(function(e){e.stopImmediatePropagation()})
+
+				$document.body.addEventListener("click", capParent, true)
+				$document.body.addEventListener("click", bubParent, false)
+				$document.body.onclick = legacyParent
+
+				div.addEventListener("click", capTarget, true)
+				div.addEventListener("click", bubTarget, false)
+				div.onclick = legacyTarget
+
+				div.dispatchEvent(e)
+
+				o(capParent.callCount).equals(1)
+				o(capTarget.callCount).equals(1)
+				o(bubTarget.callCount).equals(1)
+				o(legacyTarget.callCount).equals(1)
+				o(bubParent.callCount).equals(1)
+				o(legacyParent.callCount).equals(1)
+			})
+			o("errors thrown in handlers don't interrupt the chain", function(done) {
+				var errMsg = "The presence of these six errors in the log is expected in non-Node.js environments"
+				var handler = o.spy(function(){throw errMsg})
+
+				$document.body.addEventListener("click", handler, true)
+				$document.body.addEventListener("click", handler, false)
+				$document.body.onclick = handler
+
+				div.addEventListener("click", handler, true)
+				div.addEventListener("click", handler, false)
+				div.onclick = handler
+
+				div.dispatchEvent(e)
+
+				o(handler.callCount).equals(6)
+
+				// Swallow the async errors in NodeJS
+				if (typeof process !== "undefined" && typeof process.once === "function"){
+					process.once("uncaughtException", function(e) {
+						if (e !== errMsg) throw e
+						process.once("uncaughtException", function(e) {
+							if (e !== errMsg) throw e
+							process.once("uncaughtException", function(e) {
+								if (e !== errMsg) throw e
+								process.once("uncaughtException", function(e) {
+									if (e !== errMsg) throw e
+									process.once("uncaughtException", function(e) {
+										if (e !== errMsg) throw e
+										process.once("uncaughtException", function(e) {
+											if (e !== errMsg) throw e
+											done()
+										})
+									})
+								})
+							})
+						})
+					})
+				} else {
+					done()
+				}
+			})
+		})
 	})
 	o.spec("attributes", function() {
 		o.spec("a[href]", function() {
@@ -731,6 +1257,18 @@ o.spec("domMock", function() {
 
 				o(input.checked).equals(true)
 			})
+			o("doesn't toggle on click when preventDefault() is used", function() {
+				var input = $document.createElement("input")
+				input.setAttribute("type", "checkbox")
+				input.checked = false
+				input.onclick = function(e) {e.preventDefault()}
+
+				var e = $document.createEvent("MouseEvents")
+				e.initEvent("click", true, true)
+				input.dispatchEvent(e)
+
+				o(input.checked).equals(false)
+			})
 		})
 		o.spec("input[value]", function() {
 			o("only exists in input elements", function() {