diff --git a/README.md b/README.md
index b6e99098..bfe22f41 100644
--- a/README.md
+++ b/README.md
@@ -34,6 +34,6 @@ There are over 4000 assertions in the test suite, and tests cover even difficult
 
 ## Modularity
 
-Despite the huge improvements in performance and modularity, the new codebase is smaller than v0.2.x, currently clocking at <!-- size -->7.59 KB<!-- /size --> min+gzip
+Despite the huge improvements in performance and modularity, the new codebase is smaller than v0.2.x, currently clocking at <!-- size -->7.60 KB<!-- /size --> min+gzip
 
 In addition, Mithril is now completely modular: you can import only the modules that you need and easily integrate 3rd party modules if you wish to use a different library for routing, ajax, and even rendering
diff --git a/api/tests/test-router.js b/api/tests/test-router.js
index d70a7c23..6a281237 100644
--- a/api/tests/test-router.js
+++ b/api/tests/test-router.js
@@ -1074,43 +1074,6 @@ o.spec("route", function() {
 					})
 				})
 
-				o("calling route.set invalidates pending onmatch resolution", function(done) {
-					var rendered = false
-					var resolved
-					$window.location.href = prefix + "/a"
-					route(root, "/a", {
-						"/a": {
-							onmatch: function() {
-								return new Promise(function(resolve) {
-									callAsync(function() {
-										callAsync(function() {
-											resolve({view: function() {}})
-										})
-									})
-								})
-							},
-							render: function(vnode) {
-								rendered = true
-								resolved = "a"
-							}
-						},
-						"/b": {
-							view: function() {
-								resolved = "b"
-							}
-						}
-					})
-
-					route.set("/b")
-
-					callAsync(function() {
-						o(rendered).equals(false)
-						o(resolved).equals("b")
-
-						done()
-					})
-				})
-
 				o("calling route.set invalidates pending onmatch resolution", function(done) {
 					var rendered = false
 					var resolved
diff --git a/bundler/tests/test-bundler.js b/bundler/tests/test-bundler.js
index 60859a11..3055bf7c 100644
--- a/bundler/tests/test-bundler.js
+++ b/bundler/tests/test-bundler.js
@@ -214,14 +214,14 @@ o.spec("bundler", function() {
 		write("c.js", `var cc = 2\nmodule.exports = cc`)
 		bundle(ns + "a.js", ns + "out.js")
 		
-		o(read("out.js")).equals(`new function() {\nvar x = {}\var bb = 1\nnx.b = bb\nvar cc = 1\nx.c = cc\n}`)
+		o(read("out.js")).equals(`new function() {\nvar x = {}\nvar bb = 1\nx.b = bb\nvar cc = 2\nx.c = cc\n}`)
 		
 		remove("a.js")
 		remove("b.js")
 		remove("c.js")
 		remove("out.js")
 	})
-	o("works if assigned to property", function() {
+	o("works if assigned to property using bracket notation", function() {
 		write("a.js", `var x = {}\nx["b"] = require("./b")\nx["c"] = require("./c")`)
 		write("b.js", `var bb = 1\nmodule.exports = bb`)
 		write("c.js", `var cc = 2\nmodule.exports = cc`)
diff --git a/docs/api.md b/docs/api.md
index cf25070e..872ab605 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -45,19 +45,19 @@ m.route(document.body, "/home", {
 })
 ```
 
-#### m.route.set(path) - [docs](route.md#routeset)
+#### m.route.set(path) - [docs](route.md#mrouteset)
 
 ```javascript
 m.route.set("/home")
 ```
 
-#### m.route.get() - [docs](route.md#routeget)
+#### m.route.get() - [docs](route.md#mrouteget)
 
 ```javascript
 var currentRoute = m.route.get()
 ```
 
-#### m.route.prefix(prefix) - [docs](route.md#routeprefix)
+#### m.route.prefix(prefix) - [docs](route.md#mrouteprefix)
 
 Call this before `m.route()`
 
@@ -65,7 +65,7 @@ Call this before `m.route()`
 m.route.prefix("#!")
 ```
 
-#### m.route.link() - [docs](route.md#routelink)
+#### m.route.link() - [docs](route.md#mroutelink)
 
 ```javascript
 m("a[href='/Home']", {oncreate: m.route.link}, "Go to home page")
@@ -171,4 +171,3 @@ var Counter = {
 
 m.mount(document.body, Counter)
 ```
-
diff --git a/docs/autoredraw.md b/docs/autoredraw.md
new file mode 100644
index 00000000..97a4575d
--- /dev/null
+++ b/docs/autoredraw.md
@@ -0,0 +1,122 @@
+# The auto-redraw system
+
+Mithril implements a virtual DOM diffing system for fast rendering, and in addition, it offers various mechanisms to gain granular control over the rendering of an application.
+
+When used idiomatically, Mithril employs an auto-redraw system that synchronizes the DOM whenever changes are made in the data layer. The auto-redraw system becomes enabled when you call `m.mount` or `m.route` (but it stays disabled if your app is bootstrapped solely via `m.render` calls).
+
+The auto-redraw system simply consists of triggering a re-render function behind the scenes after certain functions complete.
+
+### After event handlers
+
+Mithril automatically redraws after DOM event handlers that are defined in a Mithril view:
+
+```javascript
+var MyComponent = {
+	view: function() {
+		return m("div", {onclick: doSomething})
+	}
+}
+
+function doSomething() {
+	// a redraw happens synchronously after this function runs
+}
+
+m.mount(document.body, MyComponent)
+```
+
+You can disable an auto-redraw for specific events by setting `e.redraw` to `false`.
+
+```javascript
+var MyComponent = {
+	view: function() {
+		return m("div", {onclick: doSomething})
+	}
+}
+
+function doSomething(e) {
+	e.redraw = false
+	// no longer triggers a redraw when the div is clicked
+}
+
+m.mount(document.body, MyComponent)
+```
+
+
+### After m.request
+
+Mithril automatically redraws after [`m.request`](request.md) completes:
+
+```javascript
+m.request("/api/v1/users").then(function() {
+	// a redraw happens after this function runs
+})
+```
+
+You can disable an auto-redraw for a specific request by setting the `background` option to true:
+
+```javascript
+m.request("/api/v1/users", {background: true}).then(function() {
+	// does not trigger a redraw
+})
+```
+
+
+### After route changes
+
+Mithril automatically redraws after [`m.route.set()`](route.md#mrouteset) calls (or route changes via links that use [`m.route.link`](route.md#mroutelink)
+
+```javascript
+var RoutedComponent = {
+	view: function() {
+		return [
+			// a redraw happens asynchronously after the route changes
+			m("a", {href: "/", oncreate: m.route.link}),
+			m("div", {
+				onclick: function() {
+					m.route.set("/")
+				}
+			}),
+		]
+	}
+}
+
+m.route(document.body, "/", {
+	"/": RoutedComponent,
+})
+```
+
+---
+
+### When Mithril does not redraws
+
+Mithril does not redraw after `setTimeout`, `setInterval`, `requestAnimationFrame` and 3rd party library event handlers (e.g. Socket.io callbacks). In those cases, you must manually call [`m.redraw()`](redraw.md).
+
+Mithril also does not redraw after lifecycle methods. Parts of the UI may be redrawn after an `oninit` handler, but other parts of the UI may already have been redrawn when a given `oninit` handler fires. Handlers like `oncreate` and `onupdate` fire after the UI has been redrawn.
+
+If you need to explicitly trigger a redraw within a lifecycle method, you should call `m.redraw()`, which will trigger an asynchronous redraw.
+
+```javascript
+var StableComponent = {
+	oncreate: function(vnode) {
+		vnode.state.height = vnode.dom.offsetHeight
+		m.redraw()
+	},
+	view: function() {
+		return m("div", "This component is " + vnode.state.height + "px tall")
+	}
+}
+```
+
+Mithril does not auto-redraw vnode trees that are rendered via `m.render`. This means redraws do not occur after event changes and `m.request` calls for templates that were rendered via `m.render`. Thus, if your architecture requires manual control over when rendering occurs (as can sometimes be the case when using libraries like Redux), you should use `m.render` instead of `m.mount`.
+
+Remember that `m.render` expects a vnode tree, and `m.mount` expects a component:
+
+```javascript
+// wrap the component in a m() call for m.render
+m.render(document.body, m(MyComponent))
+
+// don't wrap the component for m.mount
+m.mount(document.body, MyComponent)
+```
+
+Mithril may also avoid auto-redrawing if the frequency of requested redraws is higher than one animation frame (typically around 16ms). This means, for example, that when using fast-firing events like `onresize` or `onscroll`, Mithril will automatically throttle the number of redraws to avoid lag.
diff --git a/docs/change-log.md b/docs/change-log.md
index b67fb4c7..c97d7d12 100644
--- a/docs/change-log.md
+++ b/docs/change-log.md
@@ -69,14 +69,14 @@ In `v0.2.x` components could be created using either `m(component)` or `m.compon
 
 ```javascript
 // These are equivalent
-m.component(component);
-m(component);
+m.component(component)
+m(component)
 ```
 
 ### `v1.x`
 
 ```javascript
-m(component);
+m(component)
 ```
 
 ---
@@ -93,7 +93,7 @@ m("div", {
         // runs on each redraw
         // isInitialized is a boolean representing if the node has been added to the DOM
     }
-});
+})
 ```
 
 ### `v1.x`
@@ -114,7 +114,7 @@ m("div", {
     onbeforeremove : function(vnode) { /*...*/ },
     // Called before the node is removed, but after onbeforeremove calls done()
     onremove : function(vnode) { /*...*/ }
-});
+})
 ```
 
 If available the DOM-Element of the vnode can be accessed at `vnode.dom`.
@@ -138,7 +138,7 @@ In v0.2.x, Mithril allowed 'redraw locks' which temporarily prevented blocked dr
 ```javascript
 m("div", {
     onclick : function(e) {
-        m.redraw.strategy("none");
+        m.redraw.strategy("none")
     }
 })
 ```
@@ -148,7 +148,7 @@ m("div", {
 ```javascript
 m("div", {
     onclick : function(e) {
-        e.redraw = false;
+        e.redraw = false
     }
 })
 ```
@@ -164,15 +164,15 @@ In `v1.x` there is no more `controller` property in components, use `oninit` ins
 ```javascript
 m.mount(document.body, {
     controller : function() {
-        var ctrl = this;
+        var ctrl = this
 
-        ctrl.fooga = 1;
+        ctrl.fooga = 1
     },
 
     view : function(ctrl) {
-        return m("p", ctrl.fooga);
+        return m("p", ctrl.fooga)
     }
-});
+})
 ```
 
 ### `v1.x`
@@ -180,29 +180,29 @@ m.mount(document.body, {
 ```javascript
 m.mount(document.body, {
     oninit : function(vnode) {
-        vnode.state.fooga = 1;
+        vnode.state.fooga = 1
     },
 
     view : function(vnode) {
-        return m("p", vnode.state.fooga);
+        return m("p", vnode.state.fooga)
     }
-});
+})
 
 // OR
 
 m.mount(document.body, {
     oninit : function(vnode) {
-        var state = this;  // this is bound to vnode.state by default
+        var state = this  // this is bound to vnode.state by default
 
-        state.fooga = 1;
+        state.fooga = 1
     },
 
     view : function(vnode) {
-        var state = this; // this is bound to vnode.state by default
+        var state = this // this is bound to vnode.state by default
 
-        return m("p", state.fooga);
+        return m("p", state.fooga)
     }
-});
+})
 ```
 
 ---
@@ -222,9 +222,9 @@ var component = {
     view : function(ctrl, options) {
         // options.fooga == 1
     }
-};
+}
 
-m("div", m.component(component, { fooga : 1 }));
+m("div", m.component(component, { fooga : 1 }))
 ```
 
 ### `v1.x`
@@ -238,9 +238,9 @@ var component = {
     view : function(vnode) {
         // vnode.attrs.fooga == 1
     }
-};
+}
 
-m("div", m(component, { fooga : 1 }));
+m("div", m(component, { fooga : 1 }))
 ```
 
 ---
@@ -258,7 +258,7 @@ m.mount(document.body, {
     view : function(ctrl, options) {
         // ...
     }
-});
+})
 ```
 
 ### `v1.x`
@@ -273,7 +273,7 @@ m.mount(document.body, {
         // Use vnode.state instead of ctrl
         // Use vnode.attrs instead of options
     }
-});
+})
 ```
 
 ---
@@ -285,13 +285,13 @@ In `v0.2.x` you could pass components as the second argument of `m()` w/o any wr
 ### `v0.2.x`
 
 ```javascript
-m("div", component);
+m("div", component)
 ```
 
 ### `v1.x`
 
 ```javascript
-m("div", m(component));
+m("div", m(component))
 ```
 
 ---
@@ -305,8 +305,8 @@ In `v1.x`, components are required instead in both cases.
 ### `v0.2.x`
 
 ```javascript
-m.mount(element, m('i', 'hello'));
-m.mount(element, m(Component, attrs));
+m.mount(element, m('i', 'hello'))
+m.mount(element, m(Component, attrs))
 
 m.route(element, '/', {
     '/': m('b', 'bye')
@@ -316,8 +316,8 @@ m.route(element, '/', {
 ### `v1.x`
 
 ```javascript
-m.mount(element, {view: function () {return m('i', 'hello')}});
-m.mount(element, {view: function () {return m(Component, attrs)}});
+m.mount(element, {view: function () {return m('i', 'hello')}})
+m.mount(element, {view: function () {return m(Component, attrs)}})
 
 m.route(element, '/', {
     '/': {view: function () {return m('b', 'bye')}}
@@ -333,15 +333,15 @@ In `v0.2.x` the routing mode could be set by assigning a string of `"pathname"`,
 ### `v0.2.x`
 
 ```javascript
-m.route.mode = "pathname";
-m.route.mode = "search";
+m.route.mode = "pathname"
+m.route.mode = "search"
 ```
 
 ### `v1.x`
 
 ```javascript
-m.route.prefix("");
-m.route.prefix("?");
+m.route.prefix("")
+m.route.prefix("?")
 ```
 
 ---
@@ -383,17 +383,17 @@ In `v0.2.x` all interaction w/ the current route happened via `m.route()`. In `v
 m.route()
 
 // Setting a new route
-m.route("/other/route");
+m.route("/other/route")
 ```
 
 ### `v1.x`
 
 ```javascript
 // Getting the current route
-m.route.get();
+m.route.get()
 
 // Setting a new route
-m.route.set("/other/route");
+m.route.set("/other/route")
 ```
 
 ---
@@ -408,10 +408,10 @@ In `v0.2.x` reading route params was all handled through the `m.route.param()` m
 m.route(document.body, "/booga", {
     "/:attr" : {
         view : function() {
-            m.route.param("attr"); // "booga"
+            m.route.param("attr") // "booga"
         }
     }
-});
+})
 ```
 
 ### `v1.x`
@@ -420,13 +420,13 @@ m.route(document.body, "/booga", {
 m.route(document.body, "/booga", {
     "/:attr" : {
         oninit : function(vnode) {
-            vnode.attrs.attr; // "booga"
+            vnode.attrs.attr // "booga"
         },
         view : function(vnode) {
-            vnode.attrs.attr; // "booga"
+            vnode.attrs.attr // "booga"
         }
     }
-});
+})
 ```
 
 ---
@@ -511,16 +511,16 @@ Additionally, if the `extract` option is passed to `m.request` the return value
 
 ```javascript
 var greetAsync = function() {
-    var deferred = m.deferred();
+    var deferred = m.deferred()
     setTimeout(function() {
-        deferred.resolve("hello");
-    }, 1000);
-    return deferred.promise;
-};
+        deferred.resolve("hello")
+    }, 1000)
+    return deferred.promise
+}
 
 greetAsync()
     .then(function(value) {return value + " world"})
-    .then(function(value) {console.log(value)}); //logs "hello world" after 1 second
+    .then(function(value) {console.log(value)}) //logs "hello world" after 1 second
 ```
 
 ### `v1.x`
@@ -528,13 +528,13 @@ greetAsync()
 ```javascript
 var greetAsync = new Promise(function(resolve){
     setTimeout(function() {
-        resolve("hello");
-    }, 1000);
-});
+        resolve("hello")
+    }, 1000)
+})
 
 greetAsync()
     .then(function(value) {return value + " world"})
-    .then(function(value) {console.log(value)}); //logs "hello world" after 1 second
+    .then(function(value) {console.log(value)}) //logs "hello world" after 1 second
 ```
 
 ---
@@ -551,7 +551,7 @@ m.sync([
     m.request({ method: 'GET', url: 'https://api.github.com/users/isiahmeadows' }),
 ])
 .then(function (users) {
-	console.log("Contributors:", users[0].name, "and", users[1].name);
+	console.log("Contributors:", users[0].name, "and", users[1].name)
 })
 ```
 
@@ -563,7 +563,7 @@ Promise.all([
     m.request({ method: 'GET', url: 'https://api.github.com/users/isiahmeadows' }),
 ])
 .then(function (users) {
-	console.log("Contributors:", users[0].name, "and", users[1].name);
+	console.log("Contributors:", users[0].name, "and", users[1].name)
 })
 ```
 
@@ -618,11 +618,11 @@ In v0.2.x it was possible to force mithril to redraw immediately by passing a tr
 ### `v0.2.x`
 
 ```javascript
-m.redraw(true); // redraws immediately & synchronously
+m.redraw(true) // redraws immediately & synchronously
 ```
 
 ### `v1.x`
 
 ```javascript
-m.redraw(); // schedules a redraw on the next requestAnimationFrame tick
+m.redraw() // schedules a redraw on the next requestAnimationFrame tick
 ```
diff --git a/docs/components.md b/docs/components.md
index 47f8d1c3..7e454519 100644
--- a/docs/components.md
+++ b/docs/components.md
@@ -28,13 +28,13 @@ m(Example)
 
 ### Passing data to components
 
-Data can be passed to component instances through an `attrs` object as a parameter in the hyperscript function:
+Data can be passed to component instances by passing an `attrs` object as the second parameter in the hyperscript function:
 
 ```javascript
 m(Example, {name: "Floyd"})
 ```
 
-`attrs` data can be accessed in the component's view or lifecycle methods via the `vnode`:
+This data can be accessed in the component's view or lifecycle methods via the `vnode.attrs`:
 
 ```javascript
 var Example = {
@@ -44,7 +44,7 @@ var Example = {
 }
 ```
 
-NOTE: Lifecycle methods can also be provided via attrs, so you should avoid using the lifecycle method names for your own callbacks as they will be invoked by Mithril. Use lifecycle methods in `attrs` only when you specifically wish to create lifecycle hooks.
+NOTE: Lifecycle methods can also be provided via the `attrs` object, so you should avoid using the lifecycle method names for your own callbacks as they would also be invoked by Mithril. Use lifecycle methods in `attrs` only when you specifically wish to create lifecycle hooks.
 
 ---
 
@@ -108,7 +108,7 @@ The state of a component can be accessed three ways: as a blueprint at initializ
 
 #### At initialization
 
-Any property attached to the component object is deep-cloned for every instance of the component. This allows simple state initialization.
+Any property attached to the component object is copied for every instance of the component. This allows simple state initialization.
 
 In the example below, `data` is a property of the `ComponentWithInitialState` component's state object.
 
diff --git a/docs/es6.md b/docs/es6.md
new file mode 100644
index 00000000..2f629223
--- /dev/null
+++ b/docs/es6.md
@@ -0,0 +1,133 @@
+# ES6
+
+- [Setup](#setup)
+- [Using Babel with Webpack](#using-babel-with-webpack)
+
+---
+
+Mithril is written in ES5, and is fully compatible with ES6 as well.
+
+In some limited environments, it's possible to use a significant subset of ES6 directly without extra tooling (for example, in internal applications that do not support IE). However, for the vast majority of use cases, a compiler toolchain like [Babel](https://babeljs.io) is required to compile ES6 features down to ES5.
+
+### Setup
+
+The simplest way to setup an ES6 compilation toolchain is via [Babel](https://babeljs.io/).
+
+Babel requires NPM, which is automatically installed when you install [Node.js](https://nodejs.org/en/). Once NPM is installed, create a project folder and run this command:
+
+```bash
+npm init -y
+```
+
+If you want to use Webpack and Babel together, [skip to the section below](#using-babel-with-webpack).
+
+To install Babel as a standalone tool, use this command:
+
+```bash
+npm install babel-cli babel-preset-es2015 babel-plugin-transform-react-jsx --save-dev
+```
+
+Create a `.babelrc` file:
+
+```json
+{
+	"presets": ["es2015"],
+	"plugins": [
+		["transform-react-jsx", {
+			"pragma": "m"
+		}]
+	]
+}
+```
+
+To run Babel as a standalone tool, run this from the command line:
+
+```bash
+babel src --out-dir bin --source-maps
+```
+
+#### Using Babel with Webpack
+
+If you're already using Webpack as a bundler, you can integrate Babel to Webpack by following these steps.
+
+```bash
+npm install babel-core babel-loader babel-preset-es2015 babel-plugin-transform-react-jsx --save-dev
+```
+
+Create a `.babelrc` file:
+
+```json
+{
+	"presets": ["es2015"],
+	"plugins": [
+		["transform-react-jsx", {
+			"pragma": "m"
+		}]
+	]
+}
+```
+
+Next, create a file called `webpack.config.js`
+
+```javascript
+module.exports = {
+	entry: './src/index.js',
+	output: {
+		path: './bin',
+		filename: 'app.js',
+	},
+	module: {
+		loaders: [{
+			test: /\.js$/,
+			exclude: /node_modules/,
+			loader: 'babel-loader'
+		}]
+	}
+}
+```
+
+This configuration assumes the source code file for the application entry point is in `src/index.js`, and this will output the bundle to `bin/app.js`.
+
+To run the bundler, setup an npm script. Open `package.json` and add this entry under `"scripts"`:
+
+```json
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch"
+	}
+}
+```
+
+You can now then run the bundler by running this from the command line:
+
+```bash
+npm start
+```
+
+#### Production build
+
+To generate a minified file, open `package.json` and add a new npm script called `build`:
+
+```json
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch",
+		"build": "webpack -p"
+	}
+}
+```
+
+You can use hooks in your production environment to run the production build script automatically. Here's an example for [Heroku](https://www.heroku.com/):
+
+```json
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch",
+		"build": "webpack -p",
+		"heroku-postbuild": "webpack -p"
+	}
+}
+```
diff --git a/docs/framework-comparison.md b/docs/framework-comparison.md
index 029d0319..95aa2137 100644
--- a/docs/framework-comparison.md
+++ b/docs/framework-comparison.md
@@ -1,12 +1,30 @@
 # Framework comparison
 
+- [Why not X?](#why-not-insert-favorite-framework-here)
+- [Why use Mithril?](#why-use-mithril)
 - [React](#react)
 - [Angular](#angular)
 - [Vue](#vue)
 
 If you're reading this page, you probably have used other frameworks to build applications, and you want to know if Mithril would help you solve your problems more effectively.
 
-In this page, you will find common arguments about other frameworks and comments on where Mithril is similar or why it differs from them.
+---
+
+## Why not [insert favorite framework here]?
+
+The reality is that most modern frameworks are fast, well-suited to build complex applications, and highly maintainable if you know how to use them effectively. There are examples of highly complex applications in the wild using just about every popular framework: Udemy uses Angular, AirBnB uses React, Gitlab uses Vue, Guild Wars 2 uses Mithril (yes, inside the game!). Clearly, these are all production-quality frameworks.
+
+As a rule of thumb, if your team is already heavily invested in another framework/library/stack, it makes more sense to stick with it, unless your team agrees that there's a very strong reason to justify a costly rewrite.
+
+If you're starting something new, do consider giving Mithril a try, if nothing else, to see how much value Mithril adopters have been getting out of 8kb (gzipped) of code.
+
+---
+
+## Why use Mithril?
+
+In one sentence: because **Mithril is pragmatic**. If you don't believe me, take 10 minutes to go over the [guide](introduction.md) to see how much it accomplishes, compared with official guides for other frameworks.
+
+Mithril is all about getting stuff done. It comes out of the box with a compact set of tools that you'll likely need for building Single Page Applications, and no distractions. The Mithril API is small and focused, and it's designed to leverage previous knowledge - e.g. view language is Javascript, HTML attributes have no syntax caveats, Promises are Promises, hyperscript selectors mirror CSS and is JSX-compatible, `m.request` option names mirror [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) - all of this so you can get up to speed fast.
 
 ---
 
@@ -14,15 +32,15 @@ In this page, you will find common arguments about other frameworks and comments
 
 React is a view library maintained by Facebook.
 
-React and Mithril share a lot of similarities
+React and Mithril share a lot of similarities. If you already learned React, you already know almost all you need to build apps with Mithril.
 
 - They both use virtual DOM, lifecycle methods and key-based reconciliation
 - They both organize views via components
 - They both use Javascript as a flow control mechanism within views
 
-The most obvious difference between React and Mithril is in their scope. React is a view library, so a typical React-based application relies on third-party libraries for routing, XHR and state management. Using a library oriented approach allows developers to customize their stack to precisely match their needs. The not-so-nice way of saying that is that too much choice can lead to analysis paralysis, excessive configuration/boilerplate complexity, and [bikeshedding](https://en.wiktionary.org/wiki/bikeshedding). At worst, it can lead to a hodge-podge of different dependencies and architectures, making it difficult for new team members to transfer knowledge from one project to the next.
+The most obvious difference between React and Mithril is in their scope. React is a view library, so a typical React-based application relies on third-party libraries for routing, XHR and state management. Using a library oriented approach allows developers to customize their stack to precisely match their needs. The not-so-nice way of saying that is that React-based architectures can vary wildly from project to project.
 
-Mithril has built-in modules for common necessities such as routing and XHR. This batteries-included approach is preferable for teams that value consistency and ease of onboarding. 
+Mithril has built-in modules for common necessities such as routing and XHR, and the [guide](simple-application.md) demonstrates idiomatic usage. This approach is preferable for teams that value consistency and ease of onboarding.
 
 ### Performance
 
@@ -80,6 +98,8 @@ React documentation is clear and well written, and includes a good API reference
 
 Mithril documentation also includes [introductory](introduction.md) [tutorials](simple-application.md), pages about advanced concepts, and an extensive API reference section, which includes input/output type information, examples for various common use cases and advice against misuse and anti-patterns. It also includes a cheatsheet for quick reference.
 
+Unfortunately, since React is limited to being only a view library, its documentation does not explore how to use React in the context of a real-life application. As a result, there are many popular state management libraries and as a result, architectures using React can differ drastically from company to company (or even between projects).
+
 ---
 
 ## Angular
@@ -121,7 +141,7 @@ Angular 2 has a lot more concepts to understand: on the language level, Typescri
 
 If we compare apples to apples, Angular 2 and Mithril have similar learning curves: in both, components are a central aspect of architecture, and both have reasonable routing and XHR tools.
 
-With that being said, Angular has a lot more concepts to learn than Mithril. It offers Angular-specific APIs for many things that often can be trivially implemented (e.g. pluralization is essentially a switch statement, "required" validation is simply an equality check, etc). Angular templates also have several layers of abstractions to emulate what Javascript does natively in Mithril - Angular's `ng-if`/`ngIf` is a *directive*, which uses a custom *parser* and *compiler* to evaluate an expression string and emulate lexical scoping... and so on.
+With that being said, Angular has a lot more concepts to learn than Mithril. It offers Angular-specific APIs for many things that often can be trivially implemented (e.g. pluralization is essentially a switch statement, "required" validation is simply an equality check, etc). Angular templates also have several layers of abstractions to emulate what Javascript does natively in Mithril - Angular's `ng-if`/`ngIf` is a *directive*, which uses a custom *parser* and *compiler* to evaluate an expression string and emulate lexical scoping... and so on. Mithril tends to be a lot more transparent, and therefore easier to reason about.
 
 ### Documentation
 
@@ -140,9 +160,9 @@ Vue and Mithril have a lot of differences but they also share some similarities:
 - They both use virtual DOM and lifecycle methods
 - Both organize views via components
 
-Vue also provides tools for routing and state management as separate modules. Vue looks very similar to Angular and provides a similar directive system, HTML-based templates and logic flow directives. It differs from Angular in that it implements a monkeypatching reactive API that overwrites native methods in a component's data (whereas Angular 1 uses dirty checking and digest/apply cycles to achieve similar results). Similar to Angular 2, Vue compiles HTML templates into functions, but the compiled functions look more like Mithril or React views, rather than Angular's compiled rendering functions.
+Vue also provides tools for routing and state management as separate modules. Vue looks very similar to Angular and provides a similar directive system, HTML-based templates and logic flow directives. It differs from Angular in that it implements a monkeypatching reactive system that overwrites native methods in a component's data (whereas Angular 1 uses dirty checking and digest/apply cycles to achieve similar results). Similar to Angular 2, Vue compiles HTML templates into functions, but the compiled functions look more like Mithril or React views, rather than Angular's compiled rendering functions.
 
-Vue is significantly smaller than Angular when comparing apples to apples, but not as small as Mithril (Vue core is around 23kb gzipped, whereas the equivalent rendering module in Mithril is around 4kb gzipped). Both have similar performance characteristics.
+Vue is significantly smaller than Angular when comparing apples to apples, but not as small as Mithril (Vue core is around 23kb gzipped, whereas the equivalent rendering module in Mithril is around 4kb gzipped). Both have similar performance characteristics, but benchmarks often suggest Mithril is slightly faster.
 
 ### Performance
 
@@ -164,14 +184,16 @@ Vue    | Mithril
 
 ### Complexity
 
-One could argue that Vue templates are more complex than Mithril due to the fact that they use Vue-specific syntax for logic flow, whereas Mithril view language is always just Javascript.
+Vue is heavily inspired by Angular and has many things that Angular does (e.g. directives, filters, `v-cloak`), but also has things inspired by React (e.g. components). As of Vue 2.0, it's also possible to write templates using hyperscript/JSX syntax (in addition to single-file components and the various webpack-based language transpilation plugins). Vue provides both bi-directional data binding and an optional Redux-like state management library, and unlike Angular, it provides no style guide. The many-ways-of-doing-one-thing approach can cause architectural fragmentation in long-lived projects.
 
-As of Vue 2.0, it's also possible to write templates using hyperscript/JSX syntax (in addition to single-file components and the various webpack-based language transpilation plugins) so Vue codebases may be less consistent across projects and have higher onboarding costs in terms of technologies compared to idiomatic Mithril projects.
-
-Vue provides both bi-directional data binding and an optional Redux-like state management library, and unlike Angular, it provides no style guide. The many-ways-of-doing-one-thing approach has a risk of causing architectural fragmentation in long-lived projects.
-
-The Mithril [tutorial](simple-application.md) implements an *idiomatic* application. This means that while it's *possible* to structure a Mithril codebase in different ways, there's a recommended way to architecture the application.
+Mithril has far less concepts and typically organizes applications in terms of components and a data layer. There are no different ways of defining components, and thus there's no need to install different sets of tools to make different flavors work.
 
 ### Documentation
 
-Both Vue and Mithril have thorough documentation. Both include a good API reference with examples, tutorials for getting started, as well as pages covering various advanced concepts.
\ No newline at end of file
+Both Vue and Mithril have good documentation. Both include a good API reference with examples, tutorials for getting started, as well as pages covering various advanced concepts.
+
+However, due to Vue's many-ways-to-do-one-thing approach, some things are not adequately documented. For example, there's no documentation on hyperscript syntax or usage.
+
+Mithril documentation typically errs on the side of being overly thorough if a topic involves things outside of the scope of Mithril. For example, when a topic involves a 3rd party library, Mithril documentation walks through the installation process for the 3rd party library.
+
+Mithril's tutorials also cover a lot more ground than Vue's: the [Vue tutorial](https://vuejs.org/v2/guide/#Getting-Started) finishes with a static list of foodstuff. [Mithril's 10 minute guide](introduction.md) covers the majority of its API and goes over key aspects of real-life applications, such as fetching data from a server and routing (and there's a [lomger, more thorough tutorial](simple-application.md) if that's not enough).
\ No newline at end of file
diff --git a/docs/generate.js b/docs/generate.js
index f8763522..a9d0f759 100644
--- a/docs/generate.js
+++ b/docs/generate.js
@@ -37,8 +37,11 @@ function generate(pathname) {
 					var modified = guides.match(link) ? guides.replace(link, replace) : methods.replace(link, replace)
 					return title + modified + "\n\n"
 				})
-				.replace(/\.md/gim, ".html") // fix links
+				.replace(/(\]\([^\)]+)(\.md)/gim, function(match, path, extension) {
+					return path + (path.match(/http/) ? extension : ".html")
+				}) // fix links
 			var html = layout
+				.replace(/\[version\]/, version) // update version
 				.replace(/\[body\]/, marked(fixed))
 				.replace(/<h5 id="([^"]+?)">([^<]+?)<\/h5>/gim, function(match, id, text) { // fix anchors
 					return "<h5 id=\"" + text.toLowerCase().replace(/\.|\[|\]|&quot;|\//g, "") + "\">" + text + "</h5>"
diff --git a/docs/guides.md b/docs/guides.md
index d2bd87da..424d7f72 100644
--- a/docs/guides.md
+++ b/docs/guides.md
@@ -2,6 +2,8 @@
 	- [Installation](installation.md)
 	- [Introduction](introduction.md)
 	- [Tutorial](simple-application.md)
+	- [JSX](jsx.md)
+	- [ES6](es6.md)
 	- [Testing](testing.md)
 	- [Examples](examples.md)
 - Key concepts
@@ -9,8 +11,8 @@
 	- [Components](components.md)
 	- [Lifecycle methods](lifecycle-methods.md)
 	- [Keys](keys.md)
+	- [Autoredraw system](autoredraw.md)
 - Social
-	- [Community chat](https://gitter.im/lhorie/mithril.js)
 	- [Mithril Jobs](https://github.com/lhorie/mithril.js/wiki/JOBS)
 	- [How to contribute](contributing.md)
 	- [Credits](credits.md)
diff --git a/docs/hyperscript.md b/docs/hyperscript.md
index 6d27a4e6..6108f2d5 100644
--- a/docs/hyperscript.md
+++ b/docs/hyperscript.md
@@ -14,6 +14,7 @@
 - [Keys](#keys)
 - [SVG and MathML](#svg-and-mathml)
 - [Making templates dynamic](#making-templates-dynamic)
+- [Converting HTML](#converting-html)
 - [Avoid anti-patterns](#avoid-anti-patterns)
 
 ---
@@ -345,6 +346,14 @@ You cannot use Javascript statements such as `if` or `for` within Javascript exp
 
 ---
 
+### Converting HTML
+
+In Mithril, well-formed HTML is valid JSX. Little effort other than copy-pasting is required to integrate an independently produced HTML file into a project using JSX.
+
+When using hyperscript, it's necessary to convert HTML to hyperscript syntax before the code can be run. To facilitate this, you can [use the HTML-to-Mithril-template converter](http://arthurclemens.github.io/mithril-template-converter/index.html).
+
+---
+
 ### Avoid Anti-patterns
 
 Although Mithril is flexible, some code patterns are discouraged:
diff --git a/docs/installation.md b/docs/installation.md
index 2d20dd11..ddc85853 100644
--- a/docs/installation.md
+++ b/docs/installation.md
@@ -20,28 +20,25 @@ If you're new to Javascript or just want a very simple setup to get your feet we
 ```bash
 # 1) install
 npm install mithril@rewrite --save
+
 npm install webpack --save
 
 # 2) add this line into the scripts section in package.json
 #	"scripts": {
-#		"build": "webpack index.js app.js --watch"
+#		"start": "webpack src/index.js bin/app.js --watch"
 #	}
 
-# 3) create an `index.js` file
+# 3) create an `src/index.js` file
 
-# 4) create an `index.html` file loading `app.js`
+# 4) create an `index.html` file containing `<script src="bin/app.js"></script>`
 
 # 5) run bundler
-npm run build
+npm start
 
 # 6) open `index.html` in the (default) browser
 open index.html
 ```
 
-The source file `index.js` will be compiled (bundled) and a browser window opens showing the result.
-Any changes in the source files will instantly get recompiled and the 
-browser will refresh reflecting the changes.
-
 #### Step by step
 
 For production-level projects, the recommended way of installing Mithril is to use NPM.
@@ -55,13 +52,13 @@ npm init --yes
 # creates a file called package.json
 ```
 
-Then, run 
+Then, to install Mithril, run:
 
 ```bash
 npm install mithril@rewrite --save
 ```
 
-to install Mithril. This will create a folder called `node_modules`, and a `mithril` folder inside of it. It will also add an entry under `dependencies` in the `package.json` file
+This will create a folder called `node_modules`, and a `mithril` folder inside of it. It will also add an entry under `dependencies` in the `package.json` file
 
 You are now ready to start using Mithril. The recommended way to structure code is to modularize it via CommonJS modules:
 
@@ -78,10 +75,10 @@ CommonJS is a de-facto standard for modularizing Javascript code, and it's used
 
 Most browser today do not natively support modularization systems (CommonJS or ES6), so modularized code must be bundled into a single Javascript file before running in a client-side application.
 
-The easiest way to create a bundle is to setup an NPM script for [Webpack](https://webpack.js.org/). To install Webpack, run this from the command line:
+A popular way for creating a bundle is to setup an NPM script for [Webpack](https://webpack.js.org/). To install Webpack, run this from the command line:
 
 ```bash
-npm install webpack --save
+npm install webpack --save-dev
 ```
 
 Open the `package.json` that you created earlier, and add an entry to the `scripts` section:
@@ -90,22 +87,24 @@ Open the `package.json` that you created earlier, and add an entry to the `scrip
 {
 	"name": "my-project",
 	"scripts": {
-		"build": "webpack index.js app.js --watch"
+		"start": "webpack src/index.js bin/app.js -d --watch"
 	}
 }
 ```
 
-Remember this is a JSON file, so object key names such as `"scripts"` and `"build"` must be inside of double quotes.
+Remember this is a JSON file, so object key names such as `"scripts"` and `"start"` must be inside of double quotes.
 
-Now you can run the script via `npm run build` in your command line window. This looks up the `webpack` command in the NPM path, reads `index.js` and creates a file called `app.js` which includes both Mithril and the `hello world` code above. If you want to run the `webpack` command directly from the command line, you need to either add `node_modules/.bin` to your PATH, or install webpack globally via `npm install webpack -g`. It's, however, recommended that you always install webpack locally and use npm scripts, to ensure builds are reproducible in different computers.
-
-```
-npm run build
-```
+The `-d` flag tells webpack to use development mode, which produces source maps for a better debugging experience.
 
 The `--watch` flag tells webpack to watch the file system and automatically recreate `app.js` if file changes are detected.
 
-Now that you have created a bundle, you can then reference the `app.js` file from an HTML file:
+Now you can run the script via `npm start` in your command line window. This looks up the `webpack` command in the NPM path, reads `index.js` and creates a file called `app.js` which includes both Mithril and the `hello world` code above. If you want to run the `webpack` command directly from the command line, you need to either add `node_modules/.bin` to your PATH, or install webpack globally via `npm install webpack -g`. It's, however, recommended that you always install webpack locally and use npm scripts, to ensure builds are reproducible in different computers.
+
+```
+npm start
+```
+
+Now that you have created a bundle, you can then reference the `bin/app.js` file from an HTML file:
 
 ```markup
 <html>
@@ -113,7 +112,7 @@ Now that you have created a bundle, you can then reference the `app.js` file fro
     <title>Hello world</title>
   </head>
   <body>
-    <script src="app.js"></script>
+    <script src="bin/app.js"></script>
   </body>
 </html>
 ```
@@ -142,6 +141,33 @@ m.mount(document.body, MyComponent)
 
 Note that in this example, we're using `m.mount`, which wires up the component to Mithril's autoredraw system. In most applications, you will want to use `m.mount` (or `m.route` if your application has multiple screens) instead of `m.render` to take advantage of the autoredraw system, rather than re-rendering manually every time a change occurs.
 
+#### Production build
+
+If you open bin/app.js, you'll notice that the Webpack bundle is not minified, so this file is not ideal for a live application. To generate a minified file, open `package.json` and add a new npm script:
+
+```
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack src/index.js bin/app.js -d --watch",
+		"build": "webpack src/index.js bin/app.js -p",
+	}
+}
+```
+
+You can use hooks in your production environment to run the production build script automatically. Here's an example for [Heroku](https://www.heroku.com/):
+
+```
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch",
+		"build": "webpack -p",
+		"heroku-postbuild": "webpack -p"
+	}
+}
+```
+
 ---
 
 ### Alternate ways to use Mithril
@@ -166,9 +192,11 @@ npm install budo -g
 npm start
 ```
 
+The source file `index.js` will be compiled (bundled) and a browser window opens showing the result. Any changes in the source files will instantly get recompiled and the browser will refresh reflecting the changes.
+
 #### Mithril bundler
 
-Mithril comes with a bundler tool of its own. It is sufficient for projects that have no other dependencies other than Mithril, but it's currently considered experimental for projects that require other NPM dependencies. It produces smaller bundles than webpack, but you should not use it in production yet.
+Mithril comes with a bundler tool of its own. It is sufficient for ES5-based projects that have no other dependencies other than Mithril, but it's currently considered experimental for projects that require other NPM dependencies. It produces smaller bundles than webpack, but you should not use it in production yet.
 
 If you want to try it and give feedback, you can open `package.json` and change the npm script for webpack to this:
 
diff --git a/docs/introduction.md b/docs/introduction.md
index 29c59a4e..671541e5 100644
--- a/docs/introduction.md
+++ b/docs/introduction.md
@@ -13,7 +13,7 @@
 ### What is Mithril?
 
 Mithril is a client-side Javascript framework for building Single Page Applications.  
-It's small (< 8kb gzip), fast and batteries-included.
+It's small (< 8kb gzip), fast and provides routing and XHR utilities out of the box.
 
 If you are an experienced developer and want to know how Mithril compares to other frameworks, see the [framework comparison](framework-comparison.md) page.
 
@@ -23,9 +23,9 @@ Note: This introduction assumes you have basic level of Javacript knowledge. If
 
 ### Getting started
 
-The easiest way to try out Mithril is to include it from a CDN, and follow this tutorial. It'll cover the majority of the API surface but it'll only take 10 minutes.
+The easiest way to try out Mithril is to include it from a CDN, and follow this tutorial. It'll cover the majority of the API surface (including routing and XHR) but it'll only take 10 minutes.
 
-Let's create an HTML file to follow along: 
+Let's create an HTML file to follow along:
 
 ```markup
 <body></body>
@@ -91,7 +91,7 @@ m("main", [
 ])
 ```
 
-Note: If you prefer `<html>` syntax, [it's possible to use it via a Babel plugin](https://babeljs.io/docs/plugins/transform-react-jsx/).
+Note: If you prefer `<html>` syntax, [it's possible to use it via a Babel plugin](jsx.md).
 
 ```markup
 // HTML syntax via Babel's JSX plugin
@@ -236,8 +236,3 @@ Clicking the button should now update the count.
 We covered how to create and update HTML, how to create components, routes for a Single Page Application, and interacted with a server via XHR.
 
 This should be enough to get you started writing the frontend for a real application. Now that you are comfortable with the basics of the Mithril API, [be sure to check out the simple application tutorial](simple-application.md), which walks you through building a realistic application.
-
-
-
-
-
diff --git a/docs/jsx.md b/docs/jsx.md
new file mode 100644
index 00000000..b439c867
--- /dev/null
+++ b/docs/jsx.md
@@ -0,0 +1,248 @@
+# JSX
+
+- [Description](#description)
+- [Setup](#setup)
+- [Using Babel with Webpack](#using-babel-with-webpack)
+- [JSX vs hyperscript](#jsx-vs-hyperscript)
+- [Converting HTML](#converting-html)
+
+---
+
+### Description
+
+JSX is a syntax extension that enables you to write HTML tags interspersed with Javascript.
+
+```jsx
+var MyComponent = {
+  view: function() {
+    return m("main", [
+      m("h1", "Hello world"),
+    ])
+  }
+}
+
+// can be written as:
+var MyComponent = {
+  view: function() {
+    return (
+      <main>
+        <h1>Hello world</h1>
+      </main>
+    )
+  }
+}
+```
+
+When using JSX, it's possible to interpolate Javascript expressions within JSX tags by using curly braces:
+
+```jsx
+var greeting = "Hello"
+var url = "http://google.com"
+var link = <a href={url}>{greeting + "!"}</a>
+// yields <a href="http://google.com">Hello</a>
+```
+
+Components can be used by using a convention of uppercasing the first letter of the component name:
+
+```jsx
+m.mount(document.body, <MyComponent />)
+// equivalent to m.mount(document.body, m(MyComponent))
+```
+
+---
+
+### Setup
+
+The simplest way to use JSX is via a [Babel](https://babeljs.io/) plugin.
+
+Babel requires NPM, which is automatically installed when you install [Node.js](https://nodejs.org/en/). Once NPM is installed, create a project folder and run this command:
+
+```bash
+npm init -y
+```
+
+If you want to use Webpack and Babel together, [skip to the section below](#using-babel-with-webpack).
+
+To install Babel as a standalone tool, use this command:
+
+```bash
+npm install babel-cli babel-preset-es2015 babel-plugin-transform-react-jsx --save-dev
+```
+
+Create a `.babelrc` file:
+
+```
+{
+	"presets": ["es2015"],
+	"plugins": [
+		["transform-react-jsx", {
+			"pragma": "m"
+		}]
+	]
+}
+```
+
+To run Babel as a standalone tool, run this from the command line:
+
+```bash
+babel src --out-dir bin --source-maps
+```
+
+#### Using Babel with Webpack
+
+If you're already using Webpack as a bundler, you can integrate Babel to Webpack by following these steps.
+
+```bash
+npm install babel-core babel-loader babel-preset-es2015 babel-plugin-transform-react-jsx --save-dev
+```
+
+Create a `.babelrc` file:
+
+```
+{
+	"presets": ["es2015"],
+	"plugins": [
+		["transform-react-jsx", {
+			"pragma": "m"
+		}]
+	]
+}
+```
+
+Next, create a file called `webpack.config.js`
+
+```javascript
+module.exports = {
+	entry: './src/index.js',
+	output: {
+		path: './bin',
+		filename: 'app.js',
+	},
+	module: {
+		loaders: [{
+			test: /\.js$/,
+			exclude: /node_modules/,
+			loader: 'babel-loader'
+		}]
+	}
+}
+```
+
+This configuration assumes the source code file for the application entry point is in `src/index.js`, and this will output the bundle to `bin/app.js`.
+
+To run the bundler, setup an npm script. Open `package.json` and add this entry under `"scripts"`:
+
+```
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch"
+	}
+}
+```
+
+You can now then run the bundler by running this from the command line:
+
+```bash
+npm start
+```
+
+#### Production build
+
+To generate a minified file, open `package.json` and add a new npm script called `build`:
+
+```
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch",
+		"build": "webpack -p",
+	}
+}
+```
+
+You can use hooks in your production environment to run the production build script automatically. Here's an example for [Heroku](https://www.heroku.com/):
+
+```
+{
+	"name": "my-project",
+	"scripts": {
+		"start": "webpack -d --watch",
+		"build": "webpack -p",
+		"heroku-postbuild": "webpack -p"
+	}
+}
+```
+
+---
+
+### JSX vs hyperscript
+
+JSX is essentially a trade-off: it introduces a non-standard syntax that cannot be run without appropriate tooling, in order to allow a developer to write HTML code using curly braces. The main benefit of using JSX instead of regular HTML is that the JSX specification is much stricter and yields syntax errors when appropriate, whereas HTML is far too forgiving and can make syntax issues difficult to spot.
+
+Unlike HTML, JSX is case-sensitive. This means `<div className="test"></div>` is different from `<div classname="test"></div>` (all lower case). The former compiles to `m("div", {className: "test"})` and the latter compiles to `m("div", {classname: "test"})`, which is not a valid way of creating a class attribute. Fortunately, Mithril supports standard HTML attribute names, and thus, this example can be written like regular HTML: `<div class="test"></div>`.
+
+JSX is useful for teams where HTML is primarily written by someone without Javascript experience, but it requires a significant amount of tooling to maintain (whereas plain HTML can, for the most part, simply be opened in a browser)
+
+Hyperscript is the compiled representation of JSX. It's designed to be readable and can also be used as-is, instead of JSX (as is done in most of the documentation). Hyperscript tends to be terser than JSX for a couple of reasons:
+
+1 - it does not require repeating the tag name in closing tags (e.g. `m("div")` vs `<div></div>`)
+2 - static attributes can be written using CSS selector syntax (i.e. `m("a.button")` vs `<div class="button"></div>`
+
+In addition, since hyperscript is plain Javascript, it's often more natural to indent than JSX:
+
+```jsx
+//JSX
+var BigComponent = {
+  activate: function() {/*...*/},
+  deactivate: function() {/*...*/},
+  update: function() {/*...*/},
+  view: function(vnode) {
+    return [
+      {vnode.attrs.items.map(function(item) {
+        return <div>{item.name}</div>
+      })}
+      <div
+        ondragover={this.activate}
+        ondragleave={this.deactivate}
+        ondragend={this.deactivate}
+        ondrop={this.update}
+        onblur={this.deactivate}
+      ></div>
+    ]
+  }
+}
+
+// hyperscript
+var BigComponent = {
+  activate: function() {/*...*/},
+  deactivate: function() {/*...*/},
+  update: function() {/*...*/},
+  view: function(vnode) {
+    return [
+      vnode.attrs.items.map(function(item) {
+        return m("div", item.name)
+      }),
+      m("div", {
+        ondragover: this.activate,
+        ondragleave: this.deactivate,
+        ondragend: this.deactivate,
+        ondrop: this.update,
+        onblur: this.deactivate,
+      })
+    ]
+  }
+}
+```
+
+In non-trivial applications, it's possible for components to have more control flow and component configuration code than markup, making a Javascript-first approach more readable than an HTML-first approach.
+
+Needless to say, since hyperscript is pure Javascript, there's no need to run a compilation step to produce runnable code.
+
+---
+
+### Converting HTML
+
+In Mithril, well-formed HTML is valid JSX. Little effort other than copy-pasting is required to integrate an independently produced HTML file into a project using JSX.
+
+When using hyperscript, it's necessary to convert HTML to hyperscript syntax before the code can be run. To facilitate this, you can [use the HTML-to-Mithril-template converter](http://arthurclemens.github.io/mithril-template-converter/index.html).
diff --git a/docs/layout.html b/docs/layout.html
index 6e96bb1b..b6e1c504 100644
--- a/docs/layout.html
+++ b/docs/layout.html
@@ -9,10 +9,11 @@
 	<body>
 		<header>
 			<section>
-				<h1>Mithril</h1>
+				<h1>Mithril <small>[version]</small></h1>
 				<nav>
 					<a href="introduction.html">Guide</a>
 					<a href="api.html">API</a>
+					<a href="https://gitter.im/lhorie/mithril.js">Chat</a>
 					<a href="https://github.com/lhorie/mithril.js">Github</a>
 				</nav>
 			</section>
diff --git a/docs/lint.js b/docs/lint.js
index 576dd181..65f6c1a5 100644
--- a/docs/lint.js
+++ b/docs/lint.js
@@ -2,6 +2,8 @@
 
 var fs = require("fs")
 var path = require("path")
+var http = require("http")
+var url = require("url")
 
 //lint rules
 function lint(file, data) {
@@ -9,6 +11,7 @@ function lint(file, data) {
 	ensureCodeIsSyntaticallyValid(file, data)
 	ensureCodeIsRunnable(file, data)
 	ensureCommentStyle(file, data)
+	ensureLinkIsValid(file, data)
 }
 
 function ensureCodeIsHighlightable(file, data) {
@@ -45,11 +48,29 @@ function ensureCodeIsRunnable(file, data) {
 
 	try {
 		initMocks()
-		new Function("console,fetch,module,require", code).call(this, silentConsole, fetch, {exports: {}}, function(dep) {
+		var module = {exports: {}}
+		new Function("console,fetch,module,require", code).call(this, silentConsole, fetch, module, function(dep) {
 			if (dep.indexOf("./mycomponent") === 0) return {view: function() {}}
 			if (dep.indexOf("mithril/ospec/ospec") === 0) return global.o
 			if (dep.indexOf("mithril/stream") === 0) return global.stream
 			if (dep === "mithril") return global.m
+			
+			if (dep === "../model/User") return {
+				list: [],
+				current: {},
+				loadList: function() {
+					return Promise.resolve({data: []})
+				},
+				load: function() {
+					return Promise.resolve({firstName: "", lastName: ""})
+				},
+				save: function() {
+					return Promise.resolve()
+				},
+			}
+			if (dep === "./view/UserList") return {view: function() {}}
+			if (dep === "./view/UserForm") return {view: function() {}}
+			if (dep === "./view/Layout") return {view: function() {}}
 		})
 	}
 	catch (e) {console.log(file + " - javascript code cannot run\n\n" + e.stack + "\n\n" + code + "\n\n---\n\n")}
@@ -64,6 +85,21 @@ function ensureCommentStyle(file, data) {
 	})
 }
 
+function ensureLinkIsValid(file, data) {
+	var links = data.match(/\]\(([^\)]+)\)/gim)
+	links.forEach(function(match) {
+		var link = match.slice(2, -1)
+		var path = link.match(/[\w-]+\.md/)
+		if (link.match(/http/)) {
+			var u = url.parse(link)
+			http.request({method: "HEAD", host: u.host, path: u.pathname, port: 80}).on("error", function() {
+				console.log(file + " - broken external link: " + link)
+			})
+		}
+		else if (path && !fs.existsSync("docs/" + path)) console.log(file + " - broken link: " + link)
+	})
+}
+
 function initMocks() {
 	global.window = require("../test-utils/browserMock")()
 	global.document = window.document
@@ -104,6 +140,9 @@ function initMocks() {
 		"GET /api/v1/users/foo:bar": function(request) {
 			return {status: 200, responseText: JSON.stringify({id: 123})}
 		},
+		"GET /files/image.svg": function(request) {
+			return {status: 200, responseText: "<svg></svg>"}
+		},
 	})
 }
 
diff --git a/docs/redraw.md b/docs/redraw.md
index ebc17283..be215e18 100644
--- a/docs/redraw.md
+++ b/docs/redraw.md
@@ -14,6 +14,8 @@ You DON'T need to call it if data is modified within the execution context of an
 
 You DO need to call it in `setTimeout`/`setInterval`/`requestAnimationFrame` callbacks, or callbacks from 3rd party libraries.
 
+Typically, `m.redraw` triggers an asynchronous redraws, but it may trigger synchronously if Mithril detects it's possible to improves performance by doing so (i.e. if no redraw was requested within the last animation frame). You should write code assuming that it always redraws asynchronously.
+
 ---
 
 ### Signature
@@ -32,4 +34,4 @@ When callbacks outside of Mithril run, you need to notify Mithril's rendering en
 
 To trigger a redraw, call `m.redraw()`. Note that `m.redraw` only works if you used `m.mount` or `m.route`. If you rendered via `m.render`, you should use `m.render` to redraw.
 
-You should not call m.redraw from a [lifecycle method](lifecycle-methods.md). Doing so will result in undefined behavior.
\ No newline at end of file
+You should not call m.redraw from a [lifecycle method](lifecycle-methods.md). Doing so will result in undefined behavior.
diff --git a/docs/render.md b/docs/render.md
index 3218c761..1a0f81d9 100644
--- a/docs/render.md
+++ b/docs/render.md
@@ -54,7 +54,7 @@ In contrast, traversing a javascript data structure has a much more predictable
 
 ### Differences from other API methods
 
-`m.render()` method is internally called by [`m.mount()`](mount.md), [`m.route()`](route.md), [`m.redraw()`](redraw.md) and [`m.request()`](request.md). It is not called by [`m.prop()`](prop.md)
+`m.render()` method is internally called by [`m.mount()`](mount.md), [`m.route()`](route.md), [`m.redraw()`](redraw.md) and [`m.request()`](request.md). It is not called after [stream updates](stream.md)
 
 Unlike with `m.mount()` and `m.route()`, a vnode tree rendered via `m.render()` does not auto-redraw in response to view events, `m.redraw()` calls or `m.request()` calls. It is a low level mechanism suitable for library authors who wish to manually control rendering instead of relying on Mithril's built-in auto-redrawing system.
 
diff --git a/docs/route.md b/docs/route.md
index c443d418..d8566215 100644
--- a/docs/route.md
+++ b/docs/route.md
@@ -3,10 +3,10 @@
 - [Description](#description)
 - [Signature](#signature)
 	- [Static members](#static-members)
-		- [route.set](#routeset)
-		- [route.get](#routeget)
-		- [route.prefix](#routeprefix)
-		- [route.link](#routelink)
+		- [m.route.set](#mrouteset)
+		- [m.route.get](#mrouteget)
+		- [m.route.prefix](#mrouteprefix)
+		- [m.route.link](#mroutelink)
 	- [RouteResolver](#routeresolver)
 		- [routeResolver.onmatch](#routeresolveronmatch)
 		- [routeResolver.render](#routeresolverrender)
@@ -62,7 +62,7 @@ Argument               | Type                                     | Required | D
 
 #### Static members
 
-##### route.set
+##### m.route.set
 
 Redirects to a matching route, or to the default route if no matching routes can be found.
 
@@ -77,7 +77,7 @@ Argument          | Type      | Required | Description
 `options.title`   | `String`  | No       | The `title` string to pass to the underlying `history.pushState` / `history.replaceState` call.
 **returns**       |           |          | Returns `undefined`
 
-##### route.get
+##### m.route.get
 
 Returns the last fully resolved routing path, without the prefix. It may differ from the path displayed in the location bar while an asynchronous route is [pending resolution](#code-splitting).
 
@@ -87,18 +87,18 @@ Argument          | Type      | Required | Description
 ----------------- | --------- | -------- | ---
 **returns**       | String    |          | Returns the last fully resolved path
 
-##### route.prefix
+##### m.route.prefix
 
-Defines a router prefix. The router prefix is a fragment of the URL that dictates the underlying [strategy](routing-strategies.md) used by the router.
+Defines a router prefix. The router prefix is a fragment of the URL that dictates the underlying [strategy](#routing-strategies) used by the router.
 
 `m.route.prefix(prefix)`
 
 Argument          | Type      | Required | Description
 ----------------- | --------- | -------- | ---
-`prefix`          | `String`  | Yes      | The prefix that controls the underlying [routing strategy](#routing-strategy) used by Mithril.
+`prefix`          | `String`  | Yes      | The prefix that controls the underlying [routing strategy](#routing-strategies) used by Mithril.
 **returns**       |           |          | Returns `undefined`
 
-##### route.link
+##### m.route.link
 
 `eventHandler = m.route.link(vnode)`
 
@@ -109,7 +109,7 @@ Argument          | Type        | Required | Description
 
 #### RouteResolver
 
-A RouterResolver is an object that contains an `onmatch` method and/or a `render` method. Both methods are optional, but at least one must be present.
+A RouterResolver is an object that contains an `onmatch` method and/or a `render` method. Both methods are optional, but at least one must be present. A RouteResolver is not a component, and therefore it does NOT have lifecycle methods. As a rule of thumb, RouteResolvers should be in the same file as the `m.route` call, whereas component definitions should be in their own modules.
 
 `routeResolver = {onmatch, render}`
 
@@ -140,7 +140,7 @@ The `render` method is called on every redraw for a matching route. It is simila
 `vnode = routeResolve.render(vnode)`
 
 Argument            | Type            | Description
-------------------- | --------------- | ----------- 
+------------------- | --------------- | -----------
 `vnode`             | `Object`        | A [vnode](vnodes.md) whose attributes object contains routing parameters. If onmatch does not return a component or a promise that resolves to a component, the vnode's `tag` field defaults to `"div"`
 `vnode.attrs`       | `Object`        | A map of URL parameter values
 **returns**         | `Vnode`         | Returns a vnode
@@ -304,7 +304,7 @@ var state = {
 		// save the state for this route
 		// this is equivalent to `history.replaceState({term: state.term}, null, location.href)`
 		m.route.set(m.route.get(), null, {replace: true, state: {term: state.term}})
-		
+
 		// navigate away
 		location.href = "https://google.com/?q=" + state.term
 	}
@@ -333,7 +333,7 @@ This way, if the user searches and presses the back button to return to the appl
 
 ### Changing router prefix
 
-The router prefix is a fragment of the URL that dictates the underlying [strategy](routing-strategies.md) used by the router.
+The router prefix is a fragment of the URL that dictates the underlying [strategy](#routing-strategies) used by the router.
 
 ```javascript
 // set to pathname strategy
@@ -545,9 +545,9 @@ m.route(document.body, "/user/list", {
 	"/user/list": {
 		onmatch: state.loadUsers,
 		render: function() {
-			return state.users.length > 0 ? state.users.map(function(user) {
+			return state.users.map(function(user) {
 				return m("div", user.id)
-			}) : "loading"
+			})
 		}
 	},
 })
diff --git a/docs/simple-application.md b/docs/simple-application.md
new file mode 100644
index 00000000..f23ff82b
--- /dev/null
+++ b/docs/simple-application.md
@@ -0,0 +1,612 @@
+# Simple application
+
+Let's develop a simple application that covers some of the major aspects of Single Page Applications
+
+First let's create an entry point for the application. Create a file `index.html`:
+
+```markup
+<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>My Application</title>
+	</head>
+	<body>
+		<script src="app.js"></script>
+	</body>
+</html>
+```
+
+The `<!doctype html>` line indicates this is an HTML 5 document. The first `charset` meta tag indicates the encoding of the document and the `viewport` meta tag dictates how mobile browsers should scale the page. The `title` tag contains the text to be displayed on the browser tab for this application, and the `script` tag indicates what is the path to the Javascript file that controls the application.
+
+We could create the entire application in a single Javascript file, but doing so would make it difficult to navigate the codebase later on. Instead, let's split the code into *modules*, and assemble these modules into a *bundle* `app.js`.
+
+There are many ways to setup a bundler tool, but most are distributed via NPM. In fact, most modern Javascript libraries and tools are distributed that way, including Mithril. NPM stands for Node.js Package Manager. To download NPM, [install Node.js](https://nodejs.org/en/); NPM is installed automatically with it. Once you have Node.js and NPM installed, open the command line and run this command:
+
+```bash
+npm init -y
+```
+
+If NPM is installed correctly, a file `package.json` will be created. This file will contain a skeleton project meta-description file. Feel free to edit the project and author information in this file.
+
+---
+
+To install Mithril, follow the instructions in the [installation](installation.md) page. Once you have a project skeleton with Mithril installed, we are ready to create the application.
+
+Let's start by creating a module to store our state. Let's create a file called `src/models/User.js`
+
+```javascript
+// src/models/User.js
+var User = {
+	list: []
+}
+
+module.exports = User
+```
+
+Now let's add code to load some data from a server. To communicate with a server, we can use Mithril's XHR utility, `m.request`. First, we include Mithril in the module:
+
+```javascript
+// src/models/User.js
+var m = require("mithril")
+
+var User = {
+	list: []
+}
+
+module.exports = User
+```
+
+Next we create a function that will trigger an XHR call. Let's call it `loadList`
+
+```javascript
+// models/User.js
+var m = require("mithril")
+
+var User = {
+	list: [],
+	loadList: function() {
+		// TODO: make XHR call
+	}
+}
+
+module.exports = User
+```
+
+Then we can add an `m.request` call to make an XHR request. For this tutorial, we'll make XHR calls to the [REM](http://rem-rest-api.herokuapp.com/) API, a mock REST API designed for rapid prototyping. This API returns a list of users from the `GET http://rem-rest-api.herokuapp.com/api/users` endpoint. Let's use `m.request` to make an XHR request and populate our data with the response of that endpoint.
+
+```javascript
+// models/User.js
+var m = require("mithril")
+
+var User = {
+	list: [],
+	loadList: function() {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users",
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.list = result.data
+		})
+	},
+}
+
+module.exports = User
+```
+
+The `method` option is an [HTTP method](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods). To retrieve data from the server without causing side-effects on the server, we need to use the `GET` method. The `url` is the address for the API endpoint. The `withCredentials: true` line indicates that we're using cookies (which is a requirement for the REM API).
+
+The `m.request` call returns a Promise that resolves to the data from the endpoint. By default, Mithril assumes a HTTP response body are in JSON format and automatically parses it into a Javascript object or array. The `.then` callback runs when the XHR request completes. In this case, the callback assigns the `reesult.data` array to `User.list`.
+
+Notice we also have a `return` statement in `loadList`. This is a general good practice when working with Promises, which allows us to register more callbacks to run after the completion of the XHR request.
+
+This simple model exposes two members: `User.list` (an array of user objects), and `User.loadList` (a method that populates `User.list` with server data).
+
+---
+
+Now, let's create a view module so that we can display data from our User model module.
+
+Create a file called `src/views/UserList.js`. First, let's include Mithril and our model, since we'll need to use both:
+
+```javascript
+var m = require("mithril")
+var User = require("../model/User")
+```
+
+Next, let's create a Mithril component. A component is simply an object that has a `view` method:
+
+```javascript
+var m = require("mithril")
+var User = require("../model/User")
+
+module.exports = {
+	view: function() {
+		// TODO add code here
+	}
+}
+```
+
+By default, Mithril views are described using [hyperscript](hyperscript.md). Hyperscript offers a terse syntax that can be indented more naturally than HTML for complex tags, and in addition, since its syntax is simply Javascript, it's possible to leverage a lot of Javascript tooling ecosystem: for example [Babel](es6.md), [JSX](jsx.md) (inline-HTML syntax extension), [eslint](http://eslint.org/) (linting), [uglifyjs](https://github.com/mishoo/UglifyJS2) (minification), [istanbul](https://github.com/gotwarlost/istanbul) (code coverage), [flow](https://flowtype.org/) (static type analysis), etc.
+
+Let's use Mithril hyperscript to create a list of items. Hyperscript is the most idiomatic way of writing Mithril views, but [JSX is another popular alternative that you could explore](jsx.md) once you're more comfortable with the basics:
+
+```javascript
+var m = require("mithril")
+var User = require("../model/User")
+
+module.exports = {
+	view: function() {
+		return m(".user-list")
+	}
+}
+```
+
+The `".user-list"` string is a CSS selector, and as you would expect, `.user-list` represents a class. When a tag is not specified, `div` is the default. So this view is equivalent to `<div class="user-list"></div>`.
+
+Now, let's reference the list of users from the model we created earlier (`User.list`) to dynamically loop through data:
+
+```javascript
+var m = require("mithril")
+var User = require("../model/User")
+
+module.exports = {
+	view: function() {
+		return m(".user-list", [
+			User.list.map(function(user) {
+				return m(".user-list-item", user.firstName + " " + user.lastName)
+			})
+		])
+	}
+}
+```
+
+Since `User.list` is a Javascript array, and since hyperscript views are just Javascript, we can loop through the array using the `.map` method. This creates an array of vnodes that represents a list of `div`s, each containing the name of a user.
+
+The problem, of course, is that we never called the `User.loadList` function. Therefore, `User.list` is still an empty array, and thus this view would render a blank page. Since we want `User.loadList` to be called when we render this component, we can take advantage of component [lifecycle methods](lifecycle-methods.md):
+
+```javascript
+var m = require("mithril")
+var User = require("../model/User")
+
+module.exports = {
+	oninit: User.loadList,
+	view: function() {
+		return m(".user-list", [
+			User.list.map(function(user) {
+				return m(".user-list-item", user.firstName + " " + user.lastName)
+			})
+		])
+	}
+}
+```
+
+Notice that we added an `oninit` method to the component, which references `User.loadList`. This means that when the component initializes, User.loadList will be called, triggering an XHR request. When the server returns a response, `User.list` gets populated.
+
+Also notice we **didn't** do `oninit: User.loadList()` (with parentheses at the end). The difference is that `oninit: User.loadList()` calls the function once and immediately, but `oninit: User.loadList` only calls that function when the component renders. This is an important difference and a common newbie mistake: calling the function immediately means that the XHR request will fire even if the component never renders. Also, if the component is ever recreated (through navigating back and forth through the application), the function won't be called again as expected.
+
+---
+
+Let's render the view from the entry point file `index.js` we created earlier:
+
+```javascript
+var m = require("mithril")
+
+var UserList = require("./view/UserList")
+
+m.mount(document.body, UserList)
+```
+
+The `m.mount` call renders the specified component (`UserList`) into a DOM element (`document.body`), erasing any DOM that were there previously. Opening the HTML file in a browser should now display a list of person names.
+
+---
+
+Right now, the list looks rather plain because we have not defined any styles.
+
+There are many similar conventions and libraries that help organize application styles nowadays. Some, like [Bootstrap](http://getbootstrap.com/) dictate a specific set of HTML structures and semantically meaningful class names, which has the upside of providing low cognitive dissonance, but the downside of making customization more difficult. Others, like [Tachyons](http://tachyons.io/) provide a large number of self-describing, atomic class names at the cost of making the class names themselves non-semantic. "CSS-in-JS" is another type of CSS system that is growing in popularity, which basically consists of scoping CSS via transpilation tooling. CSS-in-JS libraries achieve maintainability by reducing the size of the problem space, but come at the cost of having high complexity.
+
+Regardless of what CSS convention/library you choose, a good rule of thumb is to avoid the cascading aspect of CSS. To keep this tutorial simple, we'll just use plain CSS with overly explicit class names, so that the styles themselves provide the atomicity of Tachyons, and class name collisions are made unlikely through the verbosity of the class names. Plain CSS can be sufficient for low-complexity projects (e.g. 3 to 6 man-months of initial implementation time and few project phases)
+
+To add styles, let's first create a file called `styles.css` and include it in the `index.html` file
+
+```markup
+<!doctype html>
+<html>
+	<head>
+		<meta charset="utf-8" />
+		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<title>My Application</title>
+		<link href="styles.css" rel="stylesheet" />
+	</head>
+	<body>
+		<script src="app.js"></script>
+	</body>
+</html>
+```
+
+Now we can style the `UserList` component:
+
+```css
+.user-list {list-style:none;margin:0 0 10px;padding:0;}
+.user-list-item {background:#fafafa;border:1px solid #ddd;color:#333;display:block;margin:0 0 1px;padding:8px 15px;text-decoration:none;}
+.user-list-item:hover {text-decoration:underline;}
+```
+
+The CSS above is written using a convention of keeping all styles for a rule in a single line, in alphabetical order. This convention is designed to take maximum advantage of screen real estate, and makes it easier to scan the CSS selectors (since they are always on the left side) and their logical grouping, and it enforces predictable and uniform placement of CSS rules for each selector.
+
+Obviously you can use whatever spacing/indentation convention you prefer. The example above is just an illustration of a not-so-widespread convention that has strong rationales behind it, but deviate from the more widespread cosmetic-oriented spacing conventions.
+
+Reloading the browser window now should display some styled elements.
+
+---
+
+Let's add routing to our application.
+
+Routing means binding a screen to a unique URL, to create the ability to go from one "page" to another. Mithril is designed for Single Page Applications, so these "pages" aren't necessarily different HTML files in the traditional sense of the word. Instead, routing in Single Page Applications retains the same HTML file throughout its lifetime, but changes the state of the application via Javascript. Client side routing has the benefit of avoiding flashes of blank screen between page transitions, and can reduce the amount of data being sent down from the server when used in conjunction with an web service oriented architecture (i.e. an application that downloads data as JSON instead of downloading pre-rendered chunks of verbose HTML).
+
+We can add routing by changing the `m.mount` call to a `m.route` call:
+
+```javascript
+var m = require("mithril")
+
+var UserList = require("./view/UserList")
+
+m.route(document.body, "/list", {
+	"/list": UserList
+})
+```
+
+The `m.route` call specifies that the application will be rendered into `document.body`. The `"/list"` argument is the default route. That means the user will be redirected to that route if they land in a route that does not exist. The `{"/list": UserList}` object declares a map of existing routes, and what components each route resolves to.
+
+Refreshing the page in the browser should now append `#!/list` to the URL to indicate that routing is working. Since that route render UserList, we should still see the list of people on screen as before.
+
+The `#!` snippet is known as a hashbang, and it's a commonly used string for implementing client-side routing. It's possible to configure this string it via [`m.route.prefix`](route.md#mrouteprefix). Some configurations require supporting server-side changes, so we'll just continue using the hashbang for the rest of this tutorial.
+
+---
+
+Let's add another route to our application for editing users. First let's create a module called `views/UserForm.js`
+
+```javascript
+// src/views/UserForm.js
+
+module.exports = {
+	view: function() {
+		// TODO implement view
+	}
+}
+```
+
+Then we can `require` this new module from `index.js`
+
+```javascript
+// index.js
+var m = require("mithril")
+
+var UserList = require("./view/UserList")
+var UserForm = require("./view/UserForm")
+
+m.route(document.body, "/list", {
+	"/list": UserList
+})
+```
+
+And finally, we can create a route that references it:
+
+```javascript
+// index.js
+var m = require("mithril")
+
+var UserList = require("./view/UserList")
+var UserForm = require("./view/UserForm")
+
+m.route(document.body, "/list", {
+	"/list": UserList,
+	"/edit/:id": UserForm,
+})
+```
+
+Notice that the new route has a `:id` in it. This is a route parameter; you can think of it as a wild card; the route `/edit/1` would resolve to `UserForm` with an `id` of `"1"`. `/edit/2` would also resolve to `UserForm`, but with an `id` of `"2"`. And so on.
+
+Let's implement the `UserForm` component so that it can respond to those route parameters:
+
+```javascript
+// src/views/UserForm.js
+var m = require("mithril")
+
+module.exports = {
+	view: function() {
+		return m("form", [
+			m("label.label", "First name"),
+			m("input.input[type=text][placeholder=First name]"),
+			m("label.label", "Last name"),
+			m("input.input[placeholder=Last name]"),
+			m("button.button[type=submit]", "Save"),
+		])
+	}
+}
+```
+
+And let's add some styles to `styles.css`:
+
+```css
+/* styles.css */
+body,.input,.button {font:normal 16px Verdana;margin:0;}
+
+.user-list {list-style:none;margin:0 0 10px;padding:0;}
+.user-list-item {background:#fafafa;border:1px solid #ddd;color:#333;display:block;margin:0 0 1px;padding:8px 15px;text-decoration:none;}
+.user-list-item:hover {text-decoration:underline;}
+
+.label {display:block;margin:0 0 5px;}
+.input {border:1px solid #ddd;border-radius:3px;box-sizing:border-box;display:block;margin:0 0 10px;padding:10px 15px;width:100%;}
+.button {background:#eee;border:1px solid #ddd;border-radius:3px;color:#333;display:inline-block;margin:0 0 10px;padding:10px 15px;text-decoration:none;}
+.button:hover {background:#e8e8e8;}
+```
+
+Right now, this component does nothing to respond to user events. Let's add some code to our `User` model in `src/model/User.js`. This is how the code is right now:
+
+```javascript
+// src/models/User.js
+var m = require("mithril")
+
+var User = {
+	list: [],
+	loadList: function() {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users",
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.list = result.data
+		})
+	},
+}
+
+module.exports = User
+```
+
+Let's add code to allow us to load a single user
+
+```javascript
+// src/models/User.js
+var m = require("mithril")
+
+var User = {
+	list: [],
+	loadList: function() {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users",
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.list = result.data
+		})
+	},
+
+	current: {},
+	load: function(id) {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users/:id",
+			data: {id: id},
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.current = result
+		})
+	}
+}
+
+module.exports = User
+```
+
+Notice we added a `User.current` property, and a `User.load(id)` method which populates that property. We can now populate the `UserForm` view using this new method:
+
+```javascript
+// src/views/UserForm.js
+var m = require("mithril")
+var User = require("./model/User")
+
+module.exports = {
+	oninit: function(vnode) {User.load(vnode.attrs.id)},
+	view: function() {
+		return m("form", [
+			m("label.label", "First name"),
+			m("input.input[type=text][placeholder=First name]", {value: User.current.firstName}),
+			m("label.label", "Last name"),
+			m("input.input[placeholder=Last name]", {value: User.current.lastName}),
+			m("button.button[type=submit]", "Save"),
+		])
+	}
+}
+```
+
+Similar to the `UserList` component, `oninit` calls `User.load()`. Remember we had a route parameter called `:id` on the `"/edit/:id": UserForm` route? The route parameter becomes an attribute of the `UserForm` component's vnode, so routing to `/edit/1` would make `vnode.attrs.id` have a value of `"1"`.
+
+Now, let's modify the `UserList` view so that we can navigate from there to a `UserForm`:
+
+```javascript
+// src/views/UserForm.js
+var m = require("mithril")
+var User = require("../model/User")
+
+module.exports = {
+	oninit: User.loadList,
+	view: function() {
+		return m(".user-list", [
+			User.list.map(function(user) {
+				return m("a.user-list-item", {href: "/edit/" + user.id, oncreate: m.route.link}, user.firstName + " " + user.lastName)
+			})
+		])
+	}
+}
+```
+
+Here we changed `.user-list-item` to `a.user-list-item`. We added an `href` that references the route we want, and finally we added `oncreate: m.route.link`. This makes the link behave like a routed link (as opposed to merely behaving like a regular link). What this means is that clicking the link would change the part of URL that comes after the hashbang `#!` (thus changing the route without unloading the current HTML page)
+
+If you refresh the page in the browser, you should now be able to click on a person and be taken to a form. You should also be able to press the back button in the browser to go back from the form to the list of people.
+
+---
+
+The form itself still doesn't save when you press "Save". Let's make this form work:
+
+```javascript
+// src/views/UserForm.js
+var m = require("mithril")
+var User = require("./model/User")
+
+module.exports = {
+	oninit: function(vnode) {User.load(vnode.attrs.id)},
+	view: function() {
+		return m("form", [
+			m("label.label", "First name"),
+			m("input.input[type=text][placeholder=First name]", {
+				oninput: m.withAttr("value", function(value) {User.current.firstName = value}),
+				value: User.current.firstName
+			}),
+			m("label.label", "Last name"),
+			m("input.input[placeholder=Last name]", {
+				oninput: m.withAttr("value", function(value) {User.current.lastName = value}),
+				value: User.current.lastName
+			}),
+			m("button.button[type=submit]", {onclick: User.save}, "Save"),
+		])
+	}
+}
+```
+
+We added `oninput` events to both inputs, that set the `User.current.firstName` and `User.current.lastName` properties when a user types.
+
+In addition, we declared that a `User.save` method should be called when the "Save" button is pressed. Let's implement that method:
+
+```javascript
+// src/models/User.js
+var m = require("mithril")
+
+var User = {
+	list: [],
+	loadList: function() {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users",
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.list = result.data
+		})
+	},
+
+	current: {},
+	load: function(id) {
+		return m.request({
+			method: "GET",
+			url: "http://rem-rest-api.herokuapp.com/api/users/:id",
+			data: {id: id},
+			withCredentials: true,
+		})
+		.then(function(result) {
+			User.current = result
+		})
+	},
+
+	save: function() {
+		return m.request({
+			method: "PUT",
+			url: "http://rem-rest-api.herokuapp.com/api/users/:id",
+			data: User.current,
+			withCredentials: true,
+		})
+	}
+}
+
+module.exports = User
+```
+
+In the `save` method at the bottom, we used the `PUT` HTTP method to indicate that we are upserting data to the server.
+
+Now try editing the name of a user in the application. Once you save a change, you should be able to see the change reflected in the list of users.
+
+---
+
+Currently, we're only able to navigate back to the user list via the browser back button. Ideally, we would like to have a menu - or more generically, a layout where we can put global UI elements
+
+Let's create a file `src/views/Layout.js`:
+
+```javascript
+var Layout = {
+	view: function(vnode) {
+		return m("main.layout", [
+			m("nav.menu", [
+				m("a[href='/list']", {oncreate: m.route.link}, "Users")
+			]),
+			m("section", vnode.children)
+		])
+	}
+}
+```
+
+This component is fairly straightforward, it has a `<nav>` with a link to the list of users. Similar to what we did to the `/edit` links, this link uses `m.route.link` to activate routing behavior in the link.
+
+Notice there's also a `<section>` element with `vnode.children` as children. `vnode` is a reference to the vnode that represents an instance of the Layout component (i.e. the vnode returned by a `m(Layout)` call). Therefore, `vnode.children` refer to any children of that vnode.
+
+Let's add some styles:
+
+```css
+/* styles.css */
+body,.input,.button {font:normal 16px Verdana;margin:0;}
+
+.layout {margin:10px auto;max-width:1000px;}
+.menu {margin:0 0 30px;}
+
+.user-list {list-style:none;margin:0 0 10px;padding:0;}
+.user-list-item {background:#fafafa;border:1px solid #ddd;color:#333;display:block;margin:0 0 1px;padding:8px 15px;text-decoration:none;}
+.user-list-item:hover {text-decoration:underline;}
+
+.label {display:block;margin:0 0 5px;}
+.input {border:1px solid #ddd;border-radius:3px;box-sizing:border-box;display:block;margin:0 0 10px;padding:10px 15px;width:100%;}
+.button {background:#eee;border:1px solid #ddd;border-radius:3px;color:#333;display:inline-block;margin:0 0 10px;padding:10px 15px;text-decoration:none;}
+.button:hover {background:#e8e8e8;}
+```
+
+Let's change the router in `index.js` to add our layout into the mix:
+
+```javascript
+// index.js
+var m = require("mithril")
+
+var UserList = require("./view/UserList")
+var UserForm = require("./view/UserForm")
+
+m.route(document.body, "/list", {
+	"/list": {
+		render: function() {
+			return m(Layout, m(UserList))
+		}
+	},
+	"/edit/:id": {
+		render: function(vnode) {
+			return m(Layout, m(UserForm, vnode.attrs))
+		}
+	},
+})
+```
+
+We replaced each component with a [RouteResolver](route.md#routeresolver) (basically, an object with a `render` method). The `render` methods can be written in the same way as regular component views would be, by nesting `m()` calls.
+
+The interesting thing to pay attention to is how components can be used instead of a selector string in a `m()` call. Here, in the `/list` route, we have `m(Layout, m(UserList))`. This means there's a root vnode that represents an instance of `Layout`, which has a `UserList` vnode as its only child.
+
+In the `/edit/:id` route, there's also a `vnode` argument that carries the route parameters into the `UserForm` component. So if the URL is `/edit/1`, then `vnode.attrs` in this case is `{id: 1}`, and this `m(UserForm, vnode.attrs)` is equivalent to `m(UserForm, {id: 1})`. The equivalent JSX code would be `<UserForm id={vnode.attrs} />`.
+
+Refresh the page in the browser and now you'll see the global navigation on every page in the app.
+
+---
+
+This concludes the tutorial.
+
+In this tutorial, we went through the process of creating a very simple application where we can list users from a server and edit them individually. As an extra exercise, try to implement user creation and deletion on your own.
+
+If you want to see more examples of Mithril code, check the [examples](examples.md) page. If you have questions, feel free to drop by the [Mithril chat room](https://gitter.im/lhorie/mithril.js).
+
diff --git a/docs/stream.md b/docs/stream.md
index 7b6110f8..fe233f18 100644
--- a/docs/stream.md
+++ b/docs/stream.md
@@ -3,10 +3,10 @@
 - [Description](#description)
 - [Signature](#signature)
 	- [Static members](#static-members)
-		- [stream.combine](#streamcombine)
-		- [stream.merge](#streammerge)
-		- [stream.HALT](#streamhalt)
-		- [stream["fantasy-land/of"]](#streamfantasy-landof)
+		- [Stream.combine](#streamcombine)
+		- [Stream.merge](#streammerge)
+		- [Stream.HALT](#streamhalt)
+		- [Stream["fantasy-land/of"]](#streamfantasy-landof)
 	- [Instance members](#static-members)
 		- [stream.map](#streammap)
 		- [stream.end](#streamend)
@@ -34,13 +34,19 @@ For example, in a spreadsheet, if `A1 = B1 + C1`, then changing the value of `B1
 
 Similarly, you can make a stream depend on other streams so that changing the value of one automatically updates the other. This is useful when you have very expensive computations and want to only run them when necessary, as opposed to, say, on every redraw.
 
+Streams are NOT bundled with Mithril's core distribution. To include the Streams module, use:
+
+```javascript
+var Stream = require("mithril/stream")
+```
+
 ---
 
 ### Signature
 
 Creates a stream
 
-`stream = stream(value)`
+`stream = Stream(value)`
 
 Argument    | Type                 | Required | Description
 ----------- | -------------------- | -------- | ---
@@ -53,11 +59,11 @@ Argument    | Type                 | Required | Description
 
 #### Static members
 
-##### stream.combine
+##### Stream.combine
 
 Creates a computed stream that reactively updates if any of its upstreams are updated. See [combining streams](#combining-streams)
 
-`stream = stream.combine(combiner, streams)`
+`stream = Stream.combine(combiner, streams)`
 
 Argument    | Type                        | Required | Description
 ----------- | --------------------------- | -------- | ---
@@ -77,7 +83,7 @@ Specifies how the value of a computed stream is generated. See [combining stream
 
 Argument     | Type                 | Required | Description
 ------------ | -------------------- | -------- | ---
-`streams...` | splat of `Stream`s   | No       | Splat of zero or more streams that correspond to the streams passed as the second argument to [`stream.combine`](#stream-combine.md)
+`streams...` | splat of `Stream`s   | No       | Splat of zero or more streams that correspond to the streams passed as the second argument to [`stream.combine`](#stream-combine)
 `changed`    | `Array<Stream>`      | Yes      | List of streams that were affected by an update
 **returns**  | `any`                |          | Returns a computed value
 
@@ -85,28 +91,28 @@ Argument     | Type                 | Required | Description
 
 ---
 
-##### stream.merge
+##### Stream.merge
 
 Creates a stream whose value is the array of values from an array of streams
 
-`stream = stream.merge(streams)`
+`stream = Stream.merge(streams)`
 
 Argument     | Type                 | Required | Description
 ------------ | -------------------- | -------- | ---
 `streams`    | `Array<Stream>`      | Yes      | A list of streams
-**returns**  | `Stream`             |          | Returns a stream whose value is an array of input stream values 
+**returns**  | `Stream`             |          | Returns a stream whose value is an array of input stream values
 
 [How to read signatures](signatures.md)
 
 ---
 
-##### stream.HALT
+##### Stream.HALT
 
 A special value that can be returned to stream callbacks to halt execution of downstreams
 
 ---
 
-##### stream["fantasy-land/of"]
+##### Stream["fantasy-land/of"]
 
 This method is functionally identical to `stream`. It exists to conform to [Fantasy Land's Applicative specification](https://github.com/fantasyland/fantasy-land). For more information, see the [What is Fantasy Land](#what-is-fantasy-land) section.
 
@@ -498,4 +504,4 @@ Now this method works with any Fantasy Land compliant [Functor](https://github.c
 
 This example may seem convoluted, but it's a trade-off in complexity: the naive `plusOne` implementation makes sense if you have a simple system and only ever increment numbers, but the Fantasy Land implementation becomes more powerful if you have a large system with many wrapper abstractions and reused algorithms.
 
-When deciding whether you should adopt Fantasy Land, you should consider your team's familiarity with functional programming, and be realistic regarding the level of discipline that your team can commit to maintaining code quality (vs the pressure of writing new features and meeting deadlines). Functional style programming heavily depends on compiling, curating and mastering a large set of small, precisely defined functions, and therefore it's not suitable for teams who do not have solid documentation practices, and/or lack experience in functional oriented languages.
\ No newline at end of file
+When deciding whether you should adopt Fantasy Land, you should consider your team's familiarity with functional programming, and be realistic regarding the level of discipline that your team can commit to maintaining code quality (vs the pressure of writing new features and meeting deadlines). Functional style programming heavily depends on compiling, curating and mastering a large set of small, precisely defined functions, and therefore it's not suitable for teams who do not have solid documentation practices, and/or lack experience in functional oriented languages.
diff --git a/docs/style.css b/docs/style.css
index d80b9bca..ae6a7f5d 100644
--- a/docs/style.css
+++ b/docs/style.css
@@ -10,6 +10,7 @@ h2 {font-size:22px;margin:30px 0 15px;}
 h3 {font-size:20px;margin:30px 0 15px;}
 h4 {font-size:18px;margin:15px 0 15px;}
 h5 {font-weight:bold;margin:15px 0 15px;}
+h1 small {font-size:16px;}
 pre,code {background:#eee;font-family:monospace;}
 pre {border-left:3px solid #1e5799;overflow:auto;padding:10px 20px;}
 code {border:1px solid #ddd;display:inline-block;margin:0 0 1px;padding:3px;white-space:pre;}
@@ -26,7 +27,7 @@ hr {border:0;border-bottom:1px solid #ddd;margin:30px 0;}
 #signature + p code {padding:3px 10px;}
 h1 + ul {margin:40px 0 0 -270px;padding:0;position:absolute;width:250px;}
 h1 + ul + hr {display:none;}
-h1 + ul li {border-bottom:1px solid #eee;list-style:none;margin:0;padding:0;}
+h1 + ul li {list-style:none;margin:0;padding:0;}
 h1 + ul li:last-child {border-bottom:0;}
 h1 + ul ul {margin:0 0 10px;padding:0 0 0 15px;}
 h1 + ul ul li {border:0;}
diff --git a/mithril.js b/mithril.js
index 55810181..cbc385e9 100644
--- a/mithril.js
+++ b/mithril.js
@@ -4,8 +4,8 @@ function Vnode(tag, key, attrs0, children, text, dom) {
 	return {tag: tag, key: key, attrs: attrs0, children: children, text: text, dom: dom, domSize: undefined, state: {}, events: undefined, instance: undefined, skip: false}
 }
 Vnode.normalize = function(node) {
-	if (node instanceof Array) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
-	if (node != null && typeof node !== "object") return Vnode("#", undefined, undefined, node, undefined, undefined)
+	if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
+	if (node != null && typeof node !== "object") return Vnode("#", undefined, undefined, node === false ? "" : node, undefined, undefined)
 	return node
 }
 Vnode.normalizeChildren = function normalizeChildren(children) {
@@ -52,19 +52,19 @@ function hyperscript(selector) {
 					break
 				}
 			}
-			if (children instanceof Array && children.length == 1 && children[0] != null && children[0].tag === "#") text = children[0].children
+			if (Array.isArray(children) && children.length == 1 && children[0] != null && children[0].tag === "#") text = children[0].children
 			else childList = children
 			return Vnode(tag || "div", attrs.key, hasAttrs ? attrs : undefined, childList, text, undefined)
 		}
 	}
 	var attrs, children, childrenIndex
-	if (arguments[1] == null || typeof arguments[1] === "object" && arguments[1].tag === undefined && !(arguments[1] instanceof Array)) {
+	if (arguments[1] == null || typeof arguments[1] === "object" && arguments[1].tag === undefined && !Array.isArray(arguments[1])) {
 		attrs = arguments[1]
 		childrenIndex = 2
 	}
 	else childrenIndex = 1
 	if (arguments.length === childrenIndex + 1) {
-		children = arguments[childrenIndex] instanceof Array ? arguments[childrenIndex] : [arguments[childrenIndex]]
+		children = Array.isArray(arguments[childrenIndex]) ? arguments[childrenIndex] : [arguments[childrenIndex]]
 	}
 	else {
 		children = []
@@ -190,7 +190,7 @@ var buildQueryString = function(object) {
 	}
 	return args.join("&")
 	function destructure(key0, value) {
-		if (value instanceof Array) {
+		if (Array.isArray(value)) {
 			for (var i = 0; i < value.length; i++) {
 				destructure(key0 + "[" + i + "]", value[i])
 			}
@@ -332,7 +332,7 @@ var _8 = function($window, Promise) {
 	function extract(xhr) {return xhr.responseText}
 	function cast(type0, data) {
 		if (typeof type0 === "function") {
-			if (data instanceof Array) {
+			if (Array.isArray(data)) {
 				for (var i = 0; i < data.length; i++) {
 					data[i] = new type0(data[i])
 				}
@@ -430,11 +430,7 @@ var coreRenderer = function($window) {
 		return element
 	}
 	function createComponent(vnode, hooks, ns) {
-		// For object literals since `Vnode()` always sets the `state` field.
-		if (!vnode.state) vnode.state = {}
-		var constructor = function() {}
-		constructor.prototype = vnode.tag
-		vnode.state = new constructor
+		vnode.state = Object.create(vnode.tag)
 		var view = vnode.tag.view
 		if (view.reentrantLock != null) return $emptyFragment
 		view.reentrantLock = true
@@ -746,7 +742,7 @@ var coreRenderer = function($window) {
 		if (vnode.instance != null) onremove(vnode.instance)
 		else {
 			var children = vnode.children
-			if (children instanceof Array) {
+			if (Array.isArray(children)) {
 				for (var i = 0; i < children.length; i++) {
 					var child = children[i]
 					if (child != null) onremove(child)
@@ -888,7 +884,7 @@ var coreRenderer = function($window) {
 		var active = $doc.activeElement
 		// First time0 rendering into a node clears it out
 		if (dom.vnodes == null) dom.textContent = ""
-		if (!(vnodes instanceof Array)) vnodes = [vnodes]
+		if (!Array.isArray(vnodes)) vnodes = [vnodes]
 		updateNodes(dom, dom.vnodes, Vnode.normalizeChildren(vnodes), hooks, null, undefined)
 		dom.vnodes = vnodes
 		for (var i = 0; i < hooks.length; i++) hooks[i]()
diff --git a/mithril.min.js b/mithril.min.js
index ddf9415f..ad515a32 100644
--- a/mithril.min.js
+++ b/mithril.min.js
@@ -1,42 +1,42 @@
-new function(){function w(b,c,h,d,g,l){return{tag:b,key:c,attrs:h,children:d,text:g,dom:l,domSize:void 0,state:{},events:void 0,instance:void 0,skip:!1}}function A(b){if(null==b||"string"!==typeof b&&null==b.view)throw Error("The selector must be either a string or a component.");if("string"===typeof b&&void 0===G[b]){for(var c,h,d=[],g={};c=N.exec(b);){var l=c[1],m=c[2];""===l&&""!==m?h=m:"#"===l?g.id=m:"."===l?d.push(m):"["===c[3][0]&&((l=c[6])&&(l=l.replace(/\\(["'])/g,"$1").replace(/\\\\/g,"\\")),
-"class"===c[4]?d.push(l):g[c[4]]=l||!0)}0<d.length&&(g.className=d.join(" "));G[b]=function(b,c){var d=!1,a,l,n=b.className||b["class"],z;for(z in g)b[z]=g[z];void 0!==n&&(void 0!==b["class"]&&(b["class"]=void 0,b.className=n),void 0!==g.className&&(b.className=g.className+" "+n));for(z in b)if("key"!==z){d=!0;break}c instanceof Array&&1==c.length&&null!=c[0]&&"#"===c[0].tag?l=c[0].children:a=c;return w(h||"div",b.key,d?b:void 0,a,l,void 0)}}var q;null!=arguments[1]&&("object"!==typeof arguments[1]||
-void 0!==arguments[1].tag||arguments[1]instanceof Array)?d=1:(q=arguments[1],d=2);if(arguments.length===d+1)c=arguments[d]instanceof Array?arguments[d]:[arguments[d]];else for(c=[];d<arguments.length;d++)c.push(arguments[d]);return"string"===typeof b?G[b](q||{},w.normalizeChildren(c)):w(b,q&&q.key,q||{},w.normalizeChildren(c),void 0,void 0)}function O(b){var c=0,h=null,d="function"===typeof requestAnimationFrame?requestAnimationFrame:setTimeout;return function(){var g=Date.now();0===c||16<=g-c?(c=
-g,b()):null===h&&(h=d(function(){h=null;b();c=Date.now()},16-(g-c)))}}w.normalize=function(b){return b instanceof Array?w("[",void 0,void 0,w.normalizeChildren(b),void 0,void 0):null!=b&&"object"!==typeof b?w("#",void 0,void 0,b,void 0,void 0):b};w.normalizeChildren=function(b){for(var c=0;c<b.length;c++)b[c]=w.normalize(b[c]);return b};var N=/(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g,G={};A.trust=function(b){null==b&&(b="");return w("<",void 0,void 0,b,void 0,
-void 0)};A.fragment=function(b,c){return w("[",b.key,b,w.normalizeChildren(c),void 0,void 0)};var x=function(b){function c(b,a){return function p(c){var m;try{if(!a||null==c||"object"!==typeof c&&"function"!==typeof c||"function"!==typeof(m=c.then))k(function(){a||0!==b.length||console.error("Possible unhandled promise rejection:",c);for(var d=0;d<b.length;d++)b[d](c);g.length=0;l.length=0;n.state=a;n.retry=function(){p(c)}});else{if(c===d)throw new TypeError("Promise can't be resolved w/ itself");
-h(m.bind(c))}}catch(P){q(P)}}}function h(b){function a(a){return function(b){0<c++||a(b)}}var c=0,d=a(q);try{b(a(m),d)}catch(z){d(z)}}if(!(this instanceof x))throw Error("Promise must be called with `new`");if("function"!==typeof b)throw new TypeError("executor must be a function");var d=this,g=[],l=[],m=c(g,!0),q=c(l,!1),n=d._instance={resolvers:g,rejectors:l},k="function"===typeof setImmediate?setImmediate:setTimeout;h(b)};x.prototype.then=function(b,c){function h(b,c,h,m){c.push(function(a){if("function"!==
-typeof b)h(a);else try{g(b(a))}catch(C){l&&l(C)}});"function"===typeof d.retry&&m===d.state&&d.retry()}var d=this._instance,g,l,m=new x(function(b,c){g=b;l=c});h(b,d.resolvers,g,!0);h(c,d.rejectors,l,!1);return m};x.prototype["catch"]=function(b){return this.then(null,b)};x.resolve=function(b){return b instanceof x?b:new x(function(c){c(b)})};x.reject=function(b){return new x(function(c,h){h(b)})};x.all=function(b){return new x(function(c,h){var d=b.length,g=0,l=[];if(0===b.length)c([]);else for(var m=
-0;m<b.length;m++)(function(m){function n(b){g++;l[m]=b;g===d&&c(l)}null==b[m]||"object"!==typeof b[m]&&"function"!==typeof b[m]||"function"!==typeof b[m].then?n(b[m]):b[m].then(n,h)})(m)})};x.race=function(b){return new x(function(c,h){for(var d=0;d<b.length;d++)b[d].then(c,h)})};"undefined"!==typeof window?("undefined"===typeof window.Promise&&(window.Promise=x),x=window.Promise):"undefined"!==typeof global&&("undefined"===typeof global.Promise&&(global.Promise=x),x=global.Promise);var D=function(b){function c(b,
-d){if(d instanceof Array)for(var g=0;g<d.length;g++)c(b+"["+g+"]",d[g]);else if("[object Object]"===Object.prototype.toString.call(d))for(g in d)c(b+"["+g+"]",d[g]);else h.push(encodeURIComponent(b)+(null!=d&&""!==d?"="+encodeURIComponent(d):""))}if("[object Object]"!==Object.prototype.toString.call(b))return"";var h=[],d;for(d in b)c(d,b[d]);return h.join("&")},I=function(b,c){function h(){function a(){0===--b&&"function"===typeof t&&t()}var b=0;return function z(c){var d=c.then;c.then=function(){b++;
-var g=d.apply(c,arguments);g.then(a,function(c){a();if(0===b)throw c;});return z(g)};return c}}function d(a,b){if("string"===typeof a){var c=a;a=b||{};null==a.url&&(a.url=c)}return a}function g(a,b){if(null==b)return a;for(var c=a.match(/:[^\/]+/gi)||[],d=0;d<c.length;d++){var g=c[d].slice(1);null!=b[g]&&(a=a.replace(c[d],b[g]),delete b[g])}return a}function l(a,b){var c=D(b);if(""!==c){var d=0>a.indexOf("?")?"?":"&";a+=d+c}return a}function m(b){try{return""!==b?JSON.parse(b):null}catch(C){throw Error(b);
-}}function q(b){return b.responseText}function n(b,c){if("function"===typeof b)if(c instanceof Array)for(var a=0;a<c.length;a++)c[a]=new b(c[a]);else return new b(c);return c}var k=0,t;return{request:function(a,k){var t=h();a=d(a,k);var z=new c(function(c,d){null==a.method&&(a.method="GET");a.method=a.method.toUpperCase();var h="boolean"===typeof a.useBody?a.useBody:"GET"!==a.method&&"TRACE"!==a.method;"function"!==typeof a.serialize&&(a.serialize="undefined"!==typeof FormData&&a.data instanceof FormData?
-function(b){return b}:JSON.stringify);"function"!==typeof a.deserialize&&(a.deserialize=m);"function"!==typeof a.extract&&(a.extract=q);a.url=g(a.url,a.data);h?a.data=a.serialize(a.data):a.url=l(a.url,a.data);var k=new b.XMLHttpRequest;k.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&&h&&k.setRequestHeader("Content-Type","application/json; charset=utf-8");a.deserialize===
-m&&k.setRequestHeader("Accept","application/json, text/*");a.withCredentials&&(k.withCredentials=a.withCredentials);for(var t in a.headers)({}).hasOwnProperty.call(a.headers,t)&&k.setRequestHeader(t,a.headers[t]);"function"===typeof a.config&&(k=a.config(k,a)||k);k.onreadystatechange=function(){if(4===k.readyState)try{var b=a.extract!==q?a.extract(k,a):a.deserialize(a.extract(k,a));if(200<=k.status&&300>k.status||304===k.status)c(n(a.type,b));else{var g=Error(k.responseText),e;for(e in b)g[e]=b[e];
-d(g)}}catch(f){d(f)}};h&&null!=a.data?k.send(a.data):k.send()});return!0===a.background?z:t(z)},jsonp:function(a,m){var t=h();a=d(a,m);var q=new c(function(c,d){var h=a.callbackName||"_mithril_"+Math.round(1E16*Math.random())+"_"+k++,m=b.document.createElement("script");b[h]=function(d){m.parentNode.removeChild(m);c(n(a.type,d));delete b[h]};m.onerror=function(){m.parentNode.removeChild(m);d(Error("JSONP request failed"));delete b[h]};null==a.data&&(a.data={});a.url=g(a.url,a.data);a.data[a.callbackKey||
-"callback"]=h;m.src=l(a.url,a.data);b.document.documentElement.appendChild(m)});return!0===a.background?q:t(q)},setCompletionCallback:function(b){t=b}}}(window,x),M=function(b){function c(e,f,b,a,c,d,g){for(;b<a;b++){var r=f[b];null!=r&&k(e,h(r,c,g),d)}}function h(e,f,b){var a=e.tag;null!=e.attrs&&H(e.attrs,e,f);if("string"===typeof a)switch(a){case "#":return e.dom=B.createTextNode(e.children);case "<":return d(e);case "[":var r=B.createDocumentFragment();null!=e.children&&(a=e.children,c(r,a,0,
-a.length,f,null,b));e.dom=r.firstChild;e.domSize=r.childNodes.length;return r;default:var h=e.tag;switch(e.tag){case "svg":b="http://www.w3.org/2000/svg";break;case "math":b="http://www.w3.org/1998/Math/MathML"}var k=(a=e.attrs)&&a.is,h=b?k?B.createElementNS(b,h,{is:k}):B.createElementNS(b,h):k?B.createElement(h,{is:k}):B.createElement(h);e.dom=h;if(null!=a)for(r in k=b,a)z(e,r,null,a[r],k);null!=e.attrs&&null!=e.attrs.contenteditable?t(e):(null!=e.text&&(""!==e.text?h.textContent=e.text:e.children=
-[w("#",void 0,void 0,e.text,void 0,void 0)]),null!=e.children&&(r=e.children,c(h,r,0,r.length,f,null,b),f=e.attrs,"select"===e.tag&&null!=f&&("value"in f&&z(e,"value",null,f.value,void 0),"selectedIndex"in f&&z(e,"selectedIndex",null,f.selectedIndex,void 0))));return h}else return g(e,f,b)}function d(e){var f={caption:"table",thead:"table",tbody:"table",tfoot:"table",tr:"tbody",th:"tr",td:"tr",colgroup:"table",col:"colgroup"}[(e.children.match(/^\s*?<(\w+)/im)||[])[1]]||"div",f=B.createElement(f);
-f.innerHTML=e.children;e.dom=f.firstChild;e.domSize=f.childNodes.length;e=B.createDocumentFragment();for(var b;b=f.firstChild;)e.appendChild(b);return e}function g(e,f,b){e.state||(e.state={});var a=function(){};a.prototype=e.tag;e.state=new a;a=e.tag.view;if(null!=a.reentrantLock)return L;a.reentrantLock=!0;H(e.tag,e,f);e.instance=w.normalize(a.call(e.state,e));a.reentrantLock=null;if(null!=e.instance){if(e.instance===e)throw Error("A view cannot return the vnode it received as arguments");f=h(e.instance,
-f,b);e.dom=e.instance.dom;e.domSize=null!=e.dom?e.instance.domSize:0;return f}e.domSize=0;return L}function l(e,f,b,d,g,l){if(f!==b&&(null!=f||null!=b))if(null==f)c(e,b,0,b.length,d,g,void 0);else if(null==b)a(f,0,f.length,b);else{if(f.length===b.length){for(var r=!1,u=0;u<b.length;u++)if(null!=b[u]&&null!=f[u]){r=null==b[u].key&&null==f[u].key;break}if(r){for(u=0;u<f.length;u++)f[u]!==b[u]&&(null==f[u]&&null!=b[u]?k(e,h(b[u],d,l),n(f,u+1,g)):null==b[u]?a(f,u,u+1,b):m(e,f[u],b[u],d,n(f,u+1,g),!1,
-l));return}}a:{if(null!=f.pool&&Math.abs(f.pool.length-b.length)<=Math.abs(f.length-b.length)&&(r=b[0]&&b[0].children&&b[0].children.length||0,Math.abs((f.pool[0]&&f.pool[0].children&&f.pool[0].children.length||0)-r)<=Math.abs((f[0]&&f[0].children&&f[0].children.length||0)-r))){r=!0;break a}r=!1}r&&(f=f.concat(f.pool));for(var t=u=0,v=f.length-1,z=b.length-1,C;v>=u&&z>=t;){var y=f[u],p=b[t];if(y!==p||r)if(null==y)u++;else if(null==p)t++;else if(y.key===p.key)u++,t++,m(e,y,p,d,n(f,u,g),r,l),r&&y.tag===
-p.tag&&k(e,q(y),g);else if(y=f[v],y!==p||r)if(null==y)v--;else if(null==p)t++;else if(y.key===p.key)m(e,y,p,d,n(f,v+1,g),r,l),(r||t<z)&&k(e,q(y),n(f,u,g)),v--,t++;else break;else v--,t++;else u++,t++}for(;v>=u&&z>=t;){y=f[v];p=b[z];if(y!==p||r)if(null==y)v--;else{if(null!=p)if(y.key===p.key)m(e,y,p,d,n(f,v+1,g),r,l),r&&y.tag===p.tag&&k(e,q(y),g),null!=y.dom&&(g=y.dom),v--;else{if(!C){C=f;var y=v,E={},w;for(w=0;w<y;w++){var x=C[w];null!=x&&(x=x.key,null!=x&&(E[x]=w))}C=E}null!=p&&(y=C[p.key],null!=
-y?(E=f[y],m(e,E,p,d,n(f,v+1,g),r,l),k(e,q(E),g),f[y].skip=!0,null!=E.dom&&(g=E.dom)):(p=h(p,d,void 0),k(e,p,g),g=p))}z--}else v--,z--;if(z<t)break}c(e,b,t,z+1,d,g,l);a(f,u,v+1,b)}}function m(b,f,a,c,g,n,p){var e=f.tag;if(e===a.tag){a.state=f.state;a.events=f.events;var r;var u;null!=a.attrs&&"function"===typeof a.attrs.onbeforeupdate&&(r=a.attrs.onbeforeupdate.call(a.state,a,f));"string"!==typeof a.tag&&"function"===typeof a.tag.onbeforeupdate&&(u=a.tag.onbeforeupdate.call(a.state,a,f));void 0===
-r&&void 0===u||r||u?r=!1:(a.dom=f.dom,a.domSize=f.domSize,a.instance=f.instance,r=!0);if(!r)if(null!=a.attrs&&K(a.attrs,a,c,n),"string"===typeof e)switch(e){case "#":f.children.toString()!==a.children.toString()&&(f.dom.nodeValue=a.children);a.dom=f.dom;break;case "<":f.children!==a.children?(q(f),k(b,d(a),g)):(a.dom=f.dom,a.domSize=f.domSize);break;case "[":l(b,f.children,a.children,c,g,p);f=0;c=a.children;a.dom=null;if(null!=c){for(var v=0;v<c.length;v++)b=c[v],null!=b&&null!=b.dom&&(null==a.dom&&
-(a.dom=b.dom),f+=b.domSize||1);1!==f&&(a.domSize=f)}break;default:b=p;g=a.dom=f.dom;switch(a.tag){case "svg":b="http://www.w3.org/2000/svg";break;case "math":b="http://www.w3.org/1998/Math/MathML"}"textarea"===a.tag&&(null==a.attrs&&(a.attrs={}),null!=a.text&&(a.attrs.value=a.text,a.text=void 0));n=f.attrs;p=a.attrs;e=b;if(null!=p)for(v in p)z(a,v,n&&n[v],p[v],e);if(null!=n)for(v in n)null!=p&&v in p||("className"===v&&(v="class"),"o"!==v[0]||"n"!==v[1]||x(v)?"key"!==v&&a.dom.removeAttribute(v):A(a,
-v,void 0));null!=a.attrs&&null!=a.attrs.contenteditable?t(a):null!=f.text&&null!=a.text&&""!==a.text?f.text.toString()!==a.text.toString()&&(f.dom.firstChild.nodeValue=a.text):(null!=f.text&&(f.children=[w("#",void 0,void 0,f.text,void 0,f.dom.firstChild)]),null!=a.text&&(a.children=[w("#",void 0,void 0,a.text,void 0,void 0)]),l(g,f.children,a.children,c,null,b))}else a.instance=w.normalize(a.tag.view.call(a.state,a)),K(a.tag,a,c,n),null!=a.instance?(null==f.instance?k(b,h(a.instance,c,p),g):m(b,
-f.instance,a.instance,c,g,n,p),a.dom=a.instance.dom,a.domSize=a.instance.domSize):null!=f.instance?(C(f.instance,null),a.dom=void 0,a.domSize=0):(a.dom=f.dom,a.domSize=f.domSize)}else C(f,null),k(b,h(a,c,p),g)}function q(a){var b=a.domSize;if(null!=b||null==a.dom){var e=B.createDocumentFragment();if(0<b){for(a=a.dom;--b;)e.appendChild(a.nextSibling);e.insertBefore(a,e.firstChild)}return e}return a.dom}function n(a,b,c){for(;b<a.length;b++)if(null!=a[b]&&null!=a[b].dom)return a[b].dom;return c}function k(a,
-b,c){c&&c.parentNode?a.insertBefore(b,c):a.appendChild(b)}function t(a){var b=a.children;if(null!=b&&1===b.length&&"<"===b[0].tag)b=b[0].children,a.dom.innerHTML!==b&&(a.dom.innerHTML=b);else if(null!=a.text||null!=b&&0!==b.length)throw Error("Child node of a contenteditable must be trusted");}function a(a,b,c,d){for(;b<c;b++){var e=a[b];null!=e&&(e.skip?e.skip=!1:C(e,d))}}function C(a,b){function e(){if(++c===f&&(p(a),a.dom)){var e=a.domSize||1;if(1<e)for(var d=a.dom;--e;){var g=d.nextSibling,h=
-g.parentNode;null!=h&&h.removeChild(g)}e=a.dom;d=e.parentNode;null!=d&&d.removeChild(e);if(e=null!=b&&null==a.domSize)e=a.attrs,e=!(null!=e&&(e.oncreate||e.onupdate||e.onbeforeremove||e.onremove));e&&"string"===typeof a.tag&&(b.pool?b.pool.push(a):b.pool=[a])}}var f=1,c=0;if(a.attrs&&a.attrs.onbeforeremove){var d=a.attrs.onbeforeremove.call(a.state,a);null!=d&&"function"===typeof d.then&&(f++,d.then(e,e))}"string"!==typeof a.tag&&a.tag.onbeforeremove&&(d=a.tag.onbeforeremove.call(a.state,a),null!=
-d&&"function"===typeof d.then&&(f++,d.then(e,e)));e()}function p(a){a.attrs&&a.attrs.onremove&&a.attrs.onremove.call(a.state,a);"string"!==typeof a.tag&&a.tag.onremove&&a.tag.onremove.call(a.state,a);if(null!=a.instance)p(a.instance);else if(a=a.children,a instanceof Array)for(var b=0;b<a.length;b++){var e=a[b];null!=e&&p(e)}}function z(a,b,c,d,g){var e=a.dom;if("key"!==b&&"is"!==b&&(c!==d||"value"===b||"checked"===b||"selectedIndex"===b||"selected"===b&&a.dom===B.activeElement||"object"===typeof d)&&
-"undefined"!==typeof d&&!x(b)){var f=b.indexOf(":");if(-1<f&&"xlink"===b.substr(0,f))e.setAttributeNS("http://www.w3.org/1999/xlink",b.slice(f+1),d);else if("o"===b[0]&&"n"===b[1]&&"function"===typeof d)A(a,b,d);else if("style"===b)if(a=c,a===d&&(e.style.cssText="",a=null),null==d)e.style.cssText="";else if("string"===typeof d)e.style.cssText=d;else{"string"===typeof a&&(e.style.cssText="");for(var h in d)e.style[h]=d[h];if(null!=a&&"string"!==typeof a)for(h in a)h in d||(e.style[h]="")}else b in
-e&&"href"!==b&&"list"!==b&&"form"!==b&&"width"!==b&&"height"!==b&&void 0===g&&!(a.attrs.is||-1<a.tag.indexOf("-"))?"input"===a.tag&&"value"===b&&a.dom.value===d&&a.dom===B.activeElement||"select"===a.tag&&"value"===b&&a.dom.value===d&&a.dom===B.activeElement||"option"===a.tag&&"value"===b&&a.dom.value===d||(e[b]=d):"boolean"===typeof d?d?e.setAttribute(b,""):e.removeAttribute(b):e.setAttribute("className"===b?"class":b,d)}}function x(a){return"oninit"===a||"oncreate"===a||"onupdate"===a||"onremove"===
-a||"onbeforeremove"===a||"onbeforeupdate"===a}function A(a,b,c){var e=a.dom,d="function"!==typeof D?c:function(a){var b=c.call(e,a);D.call(e,a);return b};if(b in e)e[b]="function"===typeof c?d:null;else{var f=b.slice(2);void 0===a.events&&(a.events={});a.events[b]!==d&&(null!=a.events[b]&&e.removeEventListener(f,a.events[b],!1),"function"===typeof c&&(a.events[b]=d,e.addEventListener(f,a.events[b],!1)))}}function H(a,b,c){"function"===typeof a.oninit&&a.oninit.call(b.state,b);"function"===typeof a.oncreate&&
-c.push(a.oncreate.bind(b.state,b))}function K(a,b,c,d){d?H(a,b,c):"function"===typeof a.onupdate&&c.push(a.onupdate.bind(b.state,b))}var B=b.document,L=B.createDocumentFragment(),D;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=B.activeElement;null==a.vnodes&&(a.textContent="");b instanceof Array||(b=[b]);l(a,a.vnodes,w.normalizeChildren(b),c,null,void 0);a.vnodes=b;for(var e=0;e<c.length;e++)c[e]();B.activeElement!==
-d&&d.focus()},setEventCallback:function(a){return D=a}}},F=function(b){function c(b){b=d.indexOf(b);-1<b&&d.splice(b,2)}function h(){for(var b=1;b<d.length;b+=2)d[b]()}b=M(b);b.setEventCallback(function(b){!1!==b.redraw&&h()});var d=[];return{subscribe:function(b,h){c(b);d.push(b,O(h))},unsubscribe:c,redraw:h,render:b.render}}(window);I.setCompletionCallback(F.redraw);A.mount=function(b){return function(c,h){if(null===h)b.render(c,[]),b.unsubscribe(c);else{if(null==h.view)throw Error("m.mount(element, component) expects a component, not a vnode");
-b.subscribe(c,function(){b.render(c,w(h))});b.redraw()}}}(F);var Q=x,J=function(b){if(""===b||null==b)return{};"?"===b.charAt(0)&&(b=b.slice(1));b=b.split("&");for(var c={},h={},d=0;d<b.length;d++){var g=b[d].split("="),l=decodeURIComponent(g[0]),g=2===g.length?decodeURIComponent(g[1]):"";"true"===g?g=!0:"false"===g&&(g=!1);var m=l.split(/\]\[?|\[/),q=c;-1<l.indexOf("[")&&m.pop();for(var n=0;n<m.length;n++){var l=m[n],k=m[n+1],k=""==k||!isNaN(parseInt(k,10)),t=n===m.length-1;""===l&&(l=m.slice(0,
-n).join(),null==h[l]&&(h[l]=0),l=h[l]++);null==q[l]&&(q[l]=t?g:k?[]:{});q=q[l]}}return c},R=function(b){function c(c){var d=b.location[c].replace(/(?:%[a-f89][a-f0-9])+/gim,decodeURIComponent);"pathname"===c&&"/"!==d[0]&&(d="/"+d);return d}function h(b){return function(){null==m&&(m=l(function(){m=null;b()}))}}function d(b,c,d){var a=b.indexOf("?"),g=b.indexOf("#"),h=-1<a?a:-1<g?g:b.length;if(-1<a){var a=J(b.slice(a+1,-1<g?g:b.length)),k;for(k in a)c[k]=a[k]}if(-1<g)for(k in c=J(b.slice(g+1)),c)d[k]=
-c[k];return b.slice(0,h)}var g="function"===typeof b.history.pushState,l="function"===typeof setImmediate?setImmediate:setTimeout,m,q={prefix:"#!",getPath:function(){switch(q.prefix.charAt(0)){case "#":return c("hash").slice(q.prefix.length);case "?":return c("search").slice(q.prefix.length)+c("hash");default:return c("pathname").slice(q.prefix.length)+c("search")+c("hash")}},setPath:function(c,h,m){var a={},k={};c=d(c,a,k);if(null!=h){for(var l in h)a[l]=h[l];c=c.replace(/:([^\/]+)/g,function(b,
-c){delete a[c];return h[c]})}(l=D(a))&&(c+="?"+l);(k=D(k))&&(c+="#"+k);g?(k=m?m.state:null,l=m?m.title:null,b.onpopstate(),m&&m.replace?b.history.replaceState(k,l,q.prefix+c):b.history.pushState(k,l,q.prefix+c)):b.location.href=q.prefix+c},defineRoutes:function(c,k,m){function a(){var a=q.getPath(),g={},h=d(a,g,g),l=b.history.state;if(null!=l)for(var t in l)g[t]=l[t];for(var n in c)if(l=new RegExp("^"+n.replace(/:[^\/]+?\.{3}/g,"(.*?)").replace(/:[^\/]+/g,"([^\\/]+)")+"/?$"),l.test(h)){h.replace(l,
-function(){for(var b=n.match(/:[^\/]+/g)||[],d=[].slice.call(arguments,1,-2),h=0;h<b.length;h++)g[b[h].replace(/:|\./g,"")]=decodeURIComponent(d[h]);k(c[n],g,a,n)});return}m(a,g)}g?b.onpopstate=h(a):"#"===q.prefix.charAt(0)&&(b.onhashchange=a);a()}};return q};A.route=function(b,c){var h=R(b),d=function(b){return b},g,l,m,q,n,k=function(b,a,k){if(null==b)throw Error("Ensure the DOM element that was passed to `m.route` is not undefined");var p=function(){null!=g&&c.render(b,g(w(l,m.key,m)))},t=function(){h.setPath(a,
-null,{replace:!0})};h.defineRoutes(k,function(a,b,c){var h=n=function(a,k){h===n&&(l=null!=k&&"function"===typeof k.view?k:"div",m=b,q=c,n=null,g=(a.render||d).bind(a),p())};a.view?h({},a):a.onmatch?Q.resolve(a.onmatch(b,c)).then(function(b){h(a,b)},t):h(a,"div")},t);c.subscribe(b,p)};k.set=function(b,a,c){null!=n&&(c={replace:!0});n=null;h.setPath(b,a,c)};k.get=function(){return q};k.prefix=function(b){h.prefix=b};k.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)),k.set(a,void 0,void 0))}};return k}(window,F);A.withAttr=function(b,c,h){return function(d){return c.call(h||this,b in d.currentTarget?d.currentTarget[b]:d.currentTarget.getAttribute(b))}};var S=M(window);A.render=S.render;A.redraw=F.redraw;A.request=I.request;A.jsonp=I.jsonp;A.parseQueryString=J;A.buildQueryString=D;A.version=
-"1.0.0-rc.7";A.vnode=w;"undefined"!==typeof module?module.exports=A:window.m=A};
\ No newline at end of file
+new function(){function w(a,c,k,d,h,m){return{tag:a,key:c,attrs:k,children:d,text:h,dom:m,domSize:void 0,state:{},events:void 0,instance:void 0,skip:!1}}function B(a){if(null==a||"string"!==typeof a&&null==a.view)throw Error("The selector must be either a string or a component.");if("string"===typeof a&&void 0===G[a]){for(var c,k,d=[],h={};c=N.exec(a);){var m=c[1],q=c[2];""===m&&""!==q?k=q:"#"===m?h.id=q:"."===m?d.push(q):"["===c[3][0]&&((m=c[6])&&(m=m.replace(/\\(["'])/g,"$1").replace(/\\\\/g,"\\")),
+"class"===c[4]?d.push(m):h[c[4]]=m||!0)}0<d.length&&(h.className=d.join(" "));G[a]=function(a,c){var m=!1,b,t,d=a.className||a["class"],l;for(l in h)a[l]=h[l];void 0!==d&&(void 0!==a["class"]&&(a["class"]=void 0,a.className=d),void 0!==h.className&&(a.className=h.className+" "+d));for(l in a)if("key"!==l){m=!0;break}Array.isArray(c)&&1==c.length&&null!=c[0]&&"#"===c[0].tag?t=c[0].children:b=c;return w(k||"div",a.key,m?a:void 0,b,t,void 0)}}var l;null==arguments[1]||"object"===typeof arguments[1]&&
+void 0===arguments[1].tag&&!Array.isArray(arguments[1])?(l=arguments[1],d=2):d=1;if(arguments.length===d+1)c=Array.isArray(arguments[d])?arguments[d]:[arguments[d]];else for(c=[];d<arguments.length;d++)c.push(arguments[d]);return"string"===typeof a?G[a](l||{},w.normalizeChildren(c)):w(a,l&&l.key,l||{},w.normalizeChildren(c),void 0,void 0)}function O(a){var c=0,k=null,d="function"===typeof requestAnimationFrame?requestAnimationFrame:setTimeout;return function(){var h=Date.now();0===c||16<=h-c?(c=h,
+a()):null===k&&(k=d(function(){k=null;a();c=Date.now()},16-(h-c)))}}w.normalize=function(a){return Array.isArray(a)?w("[",void 0,void 0,w.normalizeChildren(a),void 0,void 0):null!=a&&"object"!==typeof a?w("#",void 0,void 0,!1===a?"":a,void 0,void 0):a};w.normalizeChildren=function(a){for(var c=0;c<a.length;c++)a[c]=w.normalize(a[c]);return a};var N=/(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g,G={};B.trust=function(a){null==a&&(a="");return w("<",void 0,void 0,a,void 0,
+void 0)};B.fragment=function(a,c){return w("[",a.key,a,w.normalizeChildren(c),void 0,void 0)};var x=function(a){function c(a,b){return function v(c){var q;try{if(!b||null==c||"object"!==typeof c&&"function"!==typeof c||"function"!==typeof(q=c.then))p(function(){b||0!==a.length||console.error("Possible unhandled promise rejection:",c);for(var d=0;d<a.length;d++)a[d](c);h.length=0;m.length=0;t.state=b;t.retry=function(){v(c)}});else{if(c===d)throw new TypeError("Promise can't be resolved w/ itself");
+k(q.bind(c))}}catch(P){l(P)}}}function k(a){function b(b){return function(a){0<c++||b(a)}}var c=0,d=b(l);try{a(b(q),d)}catch(D){d(D)}}if(!(this instanceof x))throw Error("Promise must be called with `new`");if("function"!==typeof a)throw new TypeError("executor must be a function");var d=this,h=[],m=[],q=c(h,!0),l=c(m,!1),t=d._instance={resolvers:h,rejectors:m},p="function"===typeof setImmediate?setImmediate:setTimeout;k(a)};x.prototype.then=function(a,c){function k(a,c,k,q){c.push(function(b){if("function"!==
+typeof a)k(b);else try{h(a(b))}catch(r){m&&m(r)}});"function"===typeof d.retry&&q===d.state&&d.retry()}var d=this._instance,h,m,q=new x(function(a,c){h=a;m=c});k(a,d.resolvers,h,!0);k(c,d.rejectors,m,!1);return q};x.prototype["catch"]=function(a){return this.then(null,a)};x.resolve=function(a){return a instanceof x?a:new x(function(c){c(a)})};x.reject=function(a){return new x(function(c,k){k(a)})};x.all=function(a){return new x(function(c,k){var d=a.length,h=0,m=[];if(0===a.length)c([]);else for(var q=
+0;q<a.length;q++)(function(l){function t(a){h++;m[l]=a;h===d&&c(m)}null==a[l]||"object"!==typeof a[l]&&"function"!==typeof a[l]||"function"!==typeof a[l].then?t(a[l]):a[l].then(t,k)})(q)})};x.race=function(a){return new x(function(c,k){for(var d=0;d<a.length;d++)a[d].then(c,k)})};"undefined"!==typeof window?("undefined"===typeof window.Promise&&(window.Promise=x),x=window.Promise):"undefined"!==typeof global&&("undefined"===typeof global.Promise&&(global.Promise=x),x=global.Promise);var E=function(a){function c(a,
+d){if(Array.isArray(d))for(var h=0;h<d.length;h++)c(a+"["+h+"]",d[h]);else if("[object Object]"===Object.prototype.toString.call(d))for(h in d)c(a+"["+h+"]",d[h]);else k.push(encodeURIComponent(a)+(null!=d&&""!==d?"="+encodeURIComponent(d):""))}if("[object Object]"!==Object.prototype.toString.call(a))return"";var k=[],d;for(d in a)c(d,a[d]);return k.join("&")},I=function(a,c){function k(){function b(){0===--a&&"function"===typeof z&&z()}var a=0;return function D(c){var d=c.then;c.then=function(){a++;
+var h=d.apply(c,arguments);h.then(b,function(c){b();if(0===a)throw c;});return D(h)};return c}}function d(b,a){if("string"===typeof b){var c=b;b=a||{};null==b.url&&(b.url=c)}return b}function h(b,a){if(null==a)return b;for(var c=b.match(/:[^\/]+/gi)||[],d=0;d<c.length;d++){var h=c[d].slice(1);null!=a[h]&&(b=b.replace(c[d],a[h]),delete a[h])}return b}function m(b,a){var c=E(a);if(""!==c){var d=0>b.indexOf("?")?"?":"&";b+=d+c}return b}function q(a){try{return""!==a?JSON.parse(a):null}catch(r){throw Error(a);
+}}function l(a){return a.responseText}function t(a,c){if("function"===typeof a)if(Array.isArray(c))for(var b=0;b<c.length;b++)c[b]=new a(c[b]);else return new a(c);return c}var p=0,z;return{request:function(b,p){var z=k();b=d(b,p);var r=new c(function(c,d){null==b.method&&(b.method="GET");b.method=b.method.toUpperCase();var k="boolean"===typeof b.useBody?b.useBody:"GET"!==b.method&&"TRACE"!==b.method;"function"!==typeof b.serialize&&(b.serialize="undefined"!==typeof FormData&&b.data instanceof FormData?
+function(a){return a}:JSON.stringify);"function"!==typeof b.deserialize&&(b.deserialize=q);"function"!==typeof b.extract&&(b.extract=l);b.url=h(b.url,b.data);k?b.data=b.serialize(b.data):b.url=m(b.url,b.data);var n=new a.XMLHttpRequest;n.open(b.method,b.url,"boolean"===typeof b.async?b.async:!0,"string"===typeof b.user?b.user:void 0,"string"===typeof b.password?b.password:void 0);b.serialize===JSON.stringify&&k&&n.setRequestHeader("Content-Type","application/json; charset=utf-8");b.deserialize===
+q&&n.setRequestHeader("Accept","application/json, text/*");b.withCredentials&&(n.withCredentials=b.withCredentials);for(var p in b.headers)({}).hasOwnProperty.call(b.headers,p)&&n.setRequestHeader(p,b.headers[p]);"function"===typeof b.config&&(n=b.config(n,b)||n);n.onreadystatechange=function(){if(4===n.readyState)try{var a=b.extract!==l?b.extract(n,b):b.deserialize(b.extract(n,b));if(200<=n.status&&300>n.status||304===n.status)c(t(b.type,a));else{var g=Error(n.responseText),e;for(e in a)g[e]=a[e];
+d(g)}}catch(f){d(f)}};k&&null!=b.data?n.send(b.data):n.send()});return!0===b.background?r:z(r)},jsonp:function(b,l){var q=k();b=d(b,l);var z=new c(function(c,d){var k=b.callbackName||"_mithril_"+Math.round(1E16*Math.random())+"_"+p++,l=a.document.createElement("script");a[k]=function(d){l.parentNode.removeChild(l);c(t(b.type,d));delete a[k]};l.onerror=function(){l.parentNode.removeChild(l);d(Error("JSONP request failed"));delete a[k]};null==b.data&&(b.data={});b.url=h(b.url,b.data);b.data[b.callbackKey||
+"callback"]=k;l.src=m(b.url,b.data);a.document.documentElement.appendChild(l)});return!0===b.background?z:q(z)},setCompletionCallback:function(a){z=a}}}(window,x),M=function(a){function c(g,e,a,b,c,d,h){for(;a<b;a++){var f=e[a];null!=f&&t(g,k(f,c,h),d)}}function k(g,e,a){var b=g.tag;null!=g.attrs&&B(g.attrs,g,e);if("string"===typeof b)switch(b){case "#":return g.dom=n.createTextNode(g.children);case "<":return d(g);case "[":var f=n.createDocumentFragment();null!=g.children&&(b=g.children,c(f,b,0,
+b.length,e,null,a));g.dom=f.firstChild;g.domSize=f.childNodes.length;return f;default:var h=g.tag;switch(g.tag){case "svg":a="http://www.w3.org/2000/svg";break;case "math":a="http://www.w3.org/1998/Math/MathML"}var l=(b=g.attrs)&&b.is,h=a?l?n.createElementNS(a,h,{is:l}):n.createElementNS(a,h):l?n.createElement(h,{is:l}):n.createElement(h);g.dom=h;if(null!=b)for(f in l=a,b)v(g,f,null,b[f],l);null!=g.attrs&&null!=g.attrs.contenteditable?p(g):(null!=g.text&&(""!==g.text?h.textContent=g.text:g.children=
+[w("#",void 0,void 0,g.text,void 0,void 0)]),null!=g.children&&(f=g.children,c(h,f,0,f.length,e,null,a),e=g.attrs,"select"===g.tag&&null!=e&&("value"in e&&v(g,"value",null,e.value,void 0),"selectedIndex"in e&&v(g,"selectedIndex",null,e.selectedIndex,void 0))));return h}else{g.state=Object.create(g.tag);f=g.tag.view;if(null!=f.reentrantLock)g=L;else if(f.reentrantLock=!0,B(g.tag,g,e),g.instance=w.normalize(f.call(g.state,g)),f.reentrantLock=null,null!=g.instance){if(g.instance===g)throw Error("A view cannot return the vnode it received as arguments");
+e=k(g.instance,e,a);g.dom=g.instance.dom;g.domSize=null!=g.dom?g.instance.domSize:0;g=e}else g.domSize=0,g=L;return g}}function d(g){var e={caption:"table",thead:"table",tbody:"table",tfoot:"table",tr:"tbody",th:"tr",td:"tr",colgroup:"table",col:"colgroup"}[(g.children.match(/^\s*?<(\w+)/im)||[])[1]]||"div",e=n.createElement(e);e.innerHTML=g.children;g.dom=e.firstChild;g.domSize=e.childNodes.length;g=n.createDocumentFragment();for(var a;a=e.firstChild;)g.appendChild(a);return g}function h(g,e,a,b,
+d,h){if(e!==a&&(null!=e||null!=a))if(null==e)c(g,a,0,a.length,b,d,void 0);else if(null==a)z(e,0,e.length,a);else{if(e.length===a.length){for(var f=!1,u=0;u<a.length;u++)if(null!=a[u]&&null!=e[u]){f=null==a[u].key&&null==e[u].key;break}if(f){for(u=0;u<e.length;u++)e[u]!==a[u]&&(null==e[u]&&null!=a[u]?t(g,k(a[u],b,h),l(e,u+1,d)):null==a[u]?z(e,u,u+1,a):m(g,e[u],a[u],b,l(e,u+1,d),!1,h));return}}a:{if(null!=e.pool&&Math.abs(e.pool.length-a.length)<=Math.abs(e.length-a.length)&&(f=a[0]&&a[0].children&&
+a[0].children.length||0,Math.abs((e.pool[0]&&e.pool[0].children&&e.pool[0].children.length||0)-f)<=Math.abs((e[0]&&e[0].children&&e[0].children.length||0)-f))){f=!0;break a}f=!1}f&&(e=e.concat(e.pool));for(var n=u=0,p=e.length-1,r=a.length-1,A;p>=u&&r>=n;){var y=e[u],v=a[n];if(y!==v||f)if(null==y)u++;else if(null==v)n++;else if(y.key===v.key)u++,n++,m(g,y,v,b,l(e,u,d),f,h),f&&y.tag===v.tag&&t(g,q(y),d);else if(y=e[p],y!==v||f)if(null==y)p--;else if(null==v)n++;else if(y.key===v.key)m(g,y,v,b,l(e,
+p+1,d),f,h),(f||n<r)&&t(g,q(y),l(e,u,d)),p--,n++;else break;else p--,n++;else u++,n++}for(;p>=u&&r>=n;){y=e[p];v=a[r];if(y!==v||f)if(null==y)p--;else{if(null!=v)if(y.key===v.key)m(g,y,v,b,l(e,p+1,d),f,h),f&&y.tag===v.tag&&t(g,q(y),d),null!=y.dom&&(d=y.dom),p--;else{if(!A){A=e;var y=p,C={},w;for(w=0;w<y;w++){var x=A[w];null!=x&&(x=x.key,null!=x&&(C[x]=w))}A=C}null!=v&&(y=A[v.key],null!=y?(C=e[y],m(g,C,v,b,l(e,p+1,d),f,h),t(g,q(C),d),e[y].skip=!0,null!=C.dom&&(d=C.dom)):(v=k(v,b,void 0),t(g,v,d),d=
+v))}r--}else p--,r--;if(r<n)break}c(g,a,n,r+1,b,d,h);z(e,u,p+1,a)}}function m(a,e,f,c,l,n,r){var g=e.tag;if(g===f.tag){f.state=e.state;f.events=e.events;var u;var z;null!=f.attrs&&"function"===typeof f.attrs.onbeforeupdate&&(u=f.attrs.onbeforeupdate.call(f.state,f,e));"string"!==typeof f.tag&&"function"===typeof f.tag.onbeforeupdate&&(z=f.tag.onbeforeupdate.call(f.state,f,e));void 0===u&&void 0===z||u||z?u=!1:(f.dom=e.dom,f.domSize=e.domSize,f.instance=e.instance,u=!0);if(!u)if(null!=f.attrs&&K(f.attrs,
+f,c,n),"string"===typeof g)switch(g){case "#":e.children.toString()!==f.children.toString()&&(e.dom.nodeValue=f.children);f.dom=e.dom;break;case "<":e.children!==f.children?(q(e),t(a,d(f),l)):(f.dom=e.dom,f.domSize=e.domSize);break;case "[":h(a,e.children,f.children,c,l,r);e=0;c=f.children;f.dom=null;if(null!=c){for(var A=0;A<c.length;A++)a=c[A],null!=a&&null!=a.dom&&(null==f.dom&&(f.dom=a.dom),e+=a.domSize||1);1!==e&&(f.domSize=e)}break;default:a=r;l=f.dom=e.dom;switch(f.tag){case "svg":a="http://www.w3.org/2000/svg";
+break;case "math":a="http://www.w3.org/1998/Math/MathML"}"textarea"===f.tag&&(null==f.attrs&&(f.attrs={}),null!=f.text&&(f.attrs.value=f.text,f.text=void 0));n=e.attrs;r=f.attrs;g=a;if(null!=r)for(A in r)v(f,A,n&&n[A],r[A],g);if(null!=n)for(A in n)null!=r&&A in r||("className"===A&&(A="class"),"o"!==A[0]||"n"!==A[1]||D(A)?"key"!==A&&f.dom.removeAttribute(A):x(f,A,void 0));null!=f.attrs&&null!=f.attrs.contenteditable?p(f):null!=e.text&&null!=f.text&&""!==f.text?e.text.toString()!==f.text.toString()&&
+(e.dom.firstChild.nodeValue=f.text):(null!=e.text&&(e.children=[w("#",void 0,void 0,e.text,void 0,e.dom.firstChild)]),null!=f.text&&(f.children=[w("#",void 0,void 0,f.text,void 0,void 0)]),h(l,e.children,f.children,c,null,a))}else f.instance=w.normalize(f.tag.view.call(f.state,f)),K(f.tag,f,c,n),null!=f.instance?(null==e.instance?t(a,k(f.instance,c,r),l):m(a,e.instance,f.instance,c,l,n,r),f.dom=f.instance.dom,f.domSize=f.instance.domSize):null!=e.instance?(b(e.instance,null),f.dom=void 0,f.domSize=
+0):(f.dom=e.dom,f.domSize=e.domSize)}else b(e,null),t(a,k(f,c,r),l)}function q(a){var g=a.domSize;if(null!=g||null==a.dom){var b=n.createDocumentFragment();if(0<g){for(a=a.dom;--g;)b.appendChild(a.nextSibling);b.insertBefore(a,b.firstChild)}return b}return a.dom}function l(a,e,b){for(;e<a.length;e++)if(null!=a[e]&&null!=a[e].dom)return a[e].dom;return b}function t(a,e,b){b&&b.parentNode?a.insertBefore(e,b):a.appendChild(e)}function p(a){var e=a.children;if(null!=e&&1===e.length&&"<"===e[0].tag)e=
+e[0].children,a.dom.innerHTML!==e&&(a.dom.innerHTML=e);else if(null!=a.text||null!=e&&0!==e.length)throw Error("Child node of a contenteditable must be trusted");}function z(a,e,f,c){for(;e<f;e++){var g=a[e];null!=g&&(g.skip?g.skip=!1:b(g,c))}}function b(a,e){function b(){if(++c===g&&(r(a),a.dom)){var b=a.domSize||1;if(1<b)for(var f=a.dom;--b;){var d=f.nextSibling,h=d.parentNode;null!=h&&h.removeChild(d)}b=a.dom;f=b.parentNode;null!=f&&f.removeChild(b);if(b=null!=e&&null==a.domSize)b=a.attrs,b=!(null!=
+b&&(b.oncreate||b.onupdate||b.onbeforeremove||b.onremove));b&&"string"===typeof a.tag&&(e.pool?e.pool.push(a):e.pool=[a])}}var g=1,c=0;if(a.attrs&&a.attrs.onbeforeremove){var d=a.attrs.onbeforeremove.call(a.state,a);null!=d&&"function"===typeof d.then&&(g++,d.then(b,b))}"string"!==typeof a.tag&&a.tag.onbeforeremove&&(d=a.tag.onbeforeremove.call(a.state,a),null!=d&&"function"===typeof d.then&&(g++,d.then(b,b)));b()}function r(a){a.attrs&&a.attrs.onremove&&a.attrs.onremove.call(a.state,a);"string"!==
+typeof a.tag&&a.tag.onremove&&a.tag.onremove.call(a.state,a);if(null!=a.instance)r(a.instance);else if(a=a.children,Array.isArray(a))for(var b=0;b<a.length;b++){var g=a[b];null!=g&&r(g)}}function v(a,b,c,d,h){var e=a.dom;if("key"!==b&&"is"!==b&&(c!==d||"value"===b||"checked"===b||"selectedIndex"===b||"selected"===b&&a.dom===n.activeElement||"object"===typeof d)&&"undefined"!==typeof d&&!D(b)){var g=b.indexOf(":");if(-1<g&&"xlink"===b.substr(0,g))e.setAttributeNS("http://www.w3.org/1999/xlink",b.slice(g+
+1),d);else if("o"===b[0]&&"n"===b[1]&&"function"===typeof d)x(a,b,d);else if("style"===b)if(a=c,a===d&&(e.style.cssText="",a=null),null==d)e.style.cssText="";else if("string"===typeof d)e.style.cssText=d;else{"string"===typeof a&&(e.style.cssText="");for(var f in d)e.style[f]=d[f];if(null!=a&&"string"!==typeof a)for(f in a)f in d||(e.style[f]="")}else b in e&&"href"!==b&&"list"!==b&&"form"!==b&&"width"!==b&&"height"!==b&&void 0===h&&!(a.attrs.is||-1<a.tag.indexOf("-"))?"input"===a.tag&&"value"===
+b&&a.dom.value===d&&a.dom===n.activeElement||"select"===a.tag&&"value"===b&&a.dom.value===d&&a.dom===n.activeElement||"option"===a.tag&&"value"===b&&a.dom.value===d||(e[b]=d):"boolean"===typeof d?d?e.setAttribute(b,""):e.removeAttribute(b):e.setAttribute("className"===b?"class":b,d)}}function D(a){return"oninit"===a||"oncreate"===a||"onupdate"===a||"onremove"===a||"onbeforeremove"===a||"onbeforeupdate"===a}function x(a,b,d){var e=a.dom,c="function"!==typeof H?d:function(a){var b=d.call(e,a);H.call(e,
+a);return b};if(b in e)e[b]="function"===typeof d?c:null;else{var f=b.slice(2);void 0===a.events&&(a.events={});a.events[b]!==c&&(null!=a.events[b]&&e.removeEventListener(f,a.events[b],!1),"function"===typeof d&&(a.events[b]=c,e.addEventListener(f,a.events[b],!1)))}}function B(a,b,d){"function"===typeof a.oninit&&a.oninit.call(b.state,b);"function"===typeof a.oncreate&&d.push(a.oncreate.bind(b.state,b))}function K(a,b,d,c){c?B(a,b,d):"function"===typeof a.onupdate&&d.push(a.onupdate.bind(b.state,
+b))}var n=a.document,L=n.createDocumentFragment(),H;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 d=[],e=n.activeElement;null==a.vnodes&&(a.textContent="");Array.isArray(b)||(b=[b]);h(a,a.vnodes,w.normalizeChildren(b),d,null,void 0);a.vnodes=b;for(var c=0;c<d.length;c++)d[c]();n.activeElement!==e&&e.focus()},setEventCallback:function(a){return H=a}}},F=function(a){function c(a){a=d.indexOf(a);-1<a&&d.splice(a,
+2)}function k(){for(var a=1;a<d.length;a+=2)d[a]()}a=M(a);a.setEventCallback(function(a){!1!==a.redraw&&k()});var d=[];return{subscribe:function(a,k){c(a);d.push(a,O(k))},unsubscribe:c,redraw:k,render:a.render}}(window);I.setCompletionCallback(F.redraw);B.mount=function(a){return function(c,k){if(null===k)a.render(c,[]),a.unsubscribe(c);else{if(null==k.view)throw Error("m.mount(element, component) expects a component, not a vnode");a.subscribe(c,function(){a.render(c,w(k))});a.redraw()}}}(F);var Q=
+x,J=function(a){if(""===a||null==a)return{};"?"===a.charAt(0)&&(a=a.slice(1));a=a.split("&");for(var c={},k={},d=0;d<a.length;d++){var h=a[d].split("="),m=decodeURIComponent(h[0]),h=2===h.length?decodeURIComponent(h[1]):"";"true"===h?h=!0:"false"===h&&(h=!1);var q=m.split(/\]\[?|\[/),l=c;-1<m.indexOf("[")&&q.pop();for(var t=0;t<q.length;t++){var m=q[t],p=q[t+1],p=""==p||!isNaN(parseInt(p,10)),z=t===q.length-1;""===m&&(m=q.slice(0,t).join(),null==k[m]&&(k[m]=0),m=k[m]++);null==l[m]&&(l[m]=z?h:p?[]:
+{});l=l[m]}}return c},R=function(a){function c(d){var c=a.location[d].replace(/(?:%[a-f89][a-f0-9])+/gim,decodeURIComponent);"pathname"===d&&"/"!==c[0]&&(c="/"+c);return c}function k(a){return function(){null==q&&(q=m(function(){q=null;a()}))}}function d(a,d,c){var b=a.indexOf("?"),h=a.indexOf("#"),l=-1<b?b:-1<h?h:a.length;if(-1<b){var b=J(a.slice(b+1,-1<h?h:a.length)),k;for(k in b)d[k]=b[k]}if(-1<h)for(k in d=J(a.slice(h+1)),d)c[k]=d[k];return a.slice(0,l)}var h="function"===typeof a.history.pushState,
+m="function"===typeof setImmediate?setImmediate:setTimeout,q,l={prefix:"#!",getPath:function(){switch(l.prefix.charAt(0)){case "#":return c("hash").slice(l.prefix.length);case "?":return c("search").slice(l.prefix.length)+c("hash");default:return c("pathname").slice(l.prefix.length)+c("search")+c("hash")}},setPath:function(c,k,m){var b={},r={};c=d(c,b,r);if(null!=k){for(var v in k)b[v]=k[v];c=c.replace(/:([^\/]+)/g,function(a,c){delete b[c];return k[c]})}(v=E(b))&&(c+="?"+v);(r=E(r))&&(c+="#"+r);
+h?(r=m?m.state:null,v=m?m.title:null,a.onpopstate(),m&&m.replace?a.history.replaceState(r,v,l.prefix+c):a.history.pushState(r,v,l.prefix+c)):a.location.href=l.prefix+c},defineRoutes:function(c,m,q){function b(){var b=l.getPath(),h={},k=d(b,h,h),p=a.history.state;if(null!=p)for(var t in p)h[t]=p[t];for(var z in c)if(p=new RegExp("^"+z.replace(/:[^\/]+?\.{3}/g,"(.*?)").replace(/:[^\/]+/g,"([^\\/]+)")+"/?$"),p.test(k)){k.replace(p,function(){for(var a=z.match(/:[^\/]+/g)||[],d=[].slice.call(arguments,
+1,-2),k=0;k<a.length;k++)h[a[k].replace(/:|\./g,"")]=decodeURIComponent(d[k]);m(c[z],h,b,z)});return}q(b,h)}h?a.onpopstate=k(b):"#"===l.prefix.charAt(0)&&(a.onhashchange=b);b()}};return l};B.route=function(a,c){var k=R(a),d=function(a){return a},h,m,q,l,t,p=function(a,b,p){if(null==a)throw Error("Ensure the DOM element that was passed to `m.route` is not undefined");var r=function(){null!=h&&c.render(a,h(w(m,q.key,q)))},z=function(){k.setPath(b,null,{replace:!0})};k.defineRoutes(p,function(a,b,c){var k=
+t=function(a,n){k===t&&(m=null!=n&&"function"===typeof n.view?n:"div",q=b,l=c,t=null,h=(a.render||d).bind(a),r())};a.view?k({},a):a.onmatch?Q.resolve(a.onmatch(b,c)).then(function(b){k(a,b)},z):k(a,"div")},z);c.subscribe(a,r)};p.set=function(a,b,c){null!=t&&(c={replace:!0});t=null;k.setPath(a,b,c)};p.get=function(){return l};p.prefix=function(a){k.prefix=a};p.link=function(a){a.dom.setAttribute("href",k.prefix+a.attrs.href);a.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(k.prefix)&&(a=a.slice(k.prefix.length)),p.set(a,void 0,void 0))}};return p}(window,F);B.withAttr=function(a,c,k){return function(d){return c.call(k||this,a in d.currentTarget?d.currentTarget[a]:d.currentTarget.getAttribute(a))}};var S=M(window);B.render=S.render;B.redraw=F.redraw;B.request=I.request;B.jsonp=I.jsonp;B.parseQueryString=J;B.buildQueryString=E;B.version="1.0.0-rc.7";B.vnode=w;"undefined"!==typeof module?module.exports=
+B:window.m=B};
\ No newline at end of file
diff --git a/ospec/README.md b/ospec/README.md
index 084d949d..676be219 100644
--- a/ospec/README.md
+++ b/ospec/README.md
@@ -4,7 +4,7 @@
 
 Noiseless testing framework
 
-Version: 1.2.2 
+Version: 1.2.3  
 License: MIT
 
 ## About
@@ -278,28 +278,19 @@ ospec will automatically evaluate all `*.js` files in any folder named `/tests`.
 	$ npm test
 ```
 
-#### (Optionally) Install Globally
+#### Installing ospec globally
+
+While it's recommended to install ospec locally to maintain reproducible environments, sometimes it may be deemed appropriate to install it globally. To do so, run this command:
 
 ```
-	$ npm i -g ospec
-	$ ospec
-```
-
-#### (Optionally) Evaluate ES6+ code:
-
-One way to accomplish this would be to include the 'babel-cli' module (`npm i babel-cli`)
-
-(This would pre-suppose that you're already using babel in your project and thus have it configured to your liking).
-
-```
-	$ babel-node ospec
+npm install ospec -g
 ```
 
 ---
 
 ## API
 
-*Square brackets denote optional arguments
+Square brackets denote optional arguments
 
 ### void o.spec(String title, Function tests)
 
diff --git a/ospec/ospec.js b/ospec/ospec.js
index 3f9e5ec4..91bbc06c 100644
--- a/ospec/ospec.js
+++ b/ospec/ospec.js
@@ -1,11 +1,11 @@
 "use strict"
 
 module.exports = new function init() {
-	var spec = {}, subjects = [], results = [], only = null, ctx = spec, start, stack = 0, nextTickish, hasProcess = typeof process === "object"
+	var spec = {}, subjects = [], results = [], only = null, ctx = spec, start, stack = 0, nextTickish, hasProcess = typeof process === "object", hasOwn = ({}).hasOwnProperty
 
 	function o(subject, predicate) {
-		ctx[subject] = predicate
 		if (predicate === undefined) return new Assert(subject)
+		ctx[unique(subject)] = predicate
 	}
 	o.before = hook("__before")
 	o.after = hook("__after")
@@ -14,7 +14,7 @@ module.exports = new function init() {
 	o.new = init
 	o.spec = function(subject, predicate) {
 		var parent = ctx
-		ctx = ctx[subject] = {}
+		ctx = ctx[unique(subject)] = {}
 		predicate()
 		ctx = parent
 	}
@@ -74,7 +74,7 @@ module.exports = new function init() {
 					var timeout = 0, delay = 200, s = new Date
 					var isDone = false
 					var body = fn.toString()
-					var arg = (body.match(/\(([\w_$]+)/) || body.match(/([\w_$]+)\s*=>/) || []).pop()
+					var arg = (body.match(/\(([\w$]+)/) || body.match(/([\w$]+)\s*=>/) || []).pop()
 					if (body.indexOf(arg) === body.lastIndexOf(arg)) throw new Error("`" + arg + "()` should be called at least once")
 					try {
 						fn(function done() {
@@ -108,6 +108,13 @@ module.exports = new function init() {
 			}
 		}
 	}
+	function unique(subject) {
+		if (hasOwn.call(ctx, subject)) {
+			console.warn("A test or a spec named `" + subject + "` was already defined")	
+			while (hasOwn.call(ctx, subject)) subject += '*'
+		}
+		return subject
+	}
 	function hook(name) {
 		return function(predicate) {
 			if (ctx[name]) throw new Error("This hook should be defined outside of a loop or inside a nested test group:\n" + predicate)
@@ -144,7 +151,7 @@ module.exports = new function init() {
 				var aKeys = Object.getOwnPropertyNames(a), bKeys = Object.getOwnPropertyNames(b)
 				if (aKeys.length !== bKeys.length) return false
 				for (var i = 0; i < aKeys.length; i++) {
-					if (!b.hasOwnProperty(aKeys[i]) || !deepEqual(a[aKeys[i]], b[aKeys[i]])) return false
+					if (!hasOwn.call(b, aKeys[i]) || !deepEqual(a[aKeys[i]], b[aKeys[i]])) return false
 				}
 				return true
 			}
diff --git a/ospec/package.json b/ospec/package.json
index 1127ad7f..fdda49db 100644
--- a/ospec/package.json
+++ b/ospec/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ospec",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "Noiseless testing framework",
   "main": "ospec.js",
   "directories": {
diff --git a/promise/tests/test-promise.js b/promise/tests/test-promise.js
index aa3a1bd9..a91b0bcb 100644
--- a/promise/tests/test-promise.js
+++ b/promise/tests/test-promise.js
@@ -27,7 +27,7 @@ o.spec("promise", function() {
 
 			o(promise instanceof Promise).equals(true)
 		})
-		o("static resolve returns promise", function() {
+		o("static reject returns promise", function() {
 			var promise = Promise.reject()
 			promise.catch(function() {})
 
@@ -141,7 +141,7 @@ o.spec("promise", function() {
 				done()
 			})
 		})
-		o("non-function onFulfilled is ignored", function(done) {
+		o("non-function onFulfilled with no second param is ignored", function(done) {
 			var promise = Promise.resolve(1)
 
 			promise.then(null).then(function(value) {
diff --git a/querystring/build.js b/querystring/build.js
index 3bea081f..55474392 100644
--- a/querystring/build.js
+++ b/querystring/build.js
@@ -10,7 +10,7 @@ module.exports = function(object) {
 	return args.join("&")
 
 	function destructure(key, value) {
-		if (value instanceof Array) {
+		if (Array.isArray(value)) {
 			for (var i = 0; i < value.length; i++) {
 				destructure(key + "[" + i + "]", value[i])
 			}
diff --git a/render/hyperscript.js b/render/hyperscript.js
index 28ce0d35..a2cf7332 100644
--- a/render/hyperscript.js
+++ b/render/hyperscript.js
@@ -41,20 +41,20 @@ function hyperscript(selector) {
 					break
 				}
 			}
-			if (children instanceof Array && children.length == 1 && children[0] != null && children[0].tag === "#") text = children[0].children
+			if (Array.isArray(children) && children.length == 1 && children[0] != null && children[0].tag === "#") text = children[0].children
 			else childList = children
 
 			return Vnode(tag || "div", attrs.key, hasAttrs ? attrs : undefined, childList, text, undefined)
 		}
 	}
 	var attrs, children, childrenIndex
-	if (arguments[1] == null || typeof arguments[1] === "object" && arguments[1].tag === undefined && !(arguments[1] instanceof Array)) {
+	if (arguments[1] == null || typeof arguments[1] === "object" && arguments[1].tag === undefined && !Array.isArray(arguments[1])) {
 		attrs = arguments[1]
 		childrenIndex = 2
 	}
 	else childrenIndex = 1
 	if (arguments.length === childrenIndex + 1) {
-		children = arguments[childrenIndex] instanceof Array ? arguments[childrenIndex] : [arguments[childrenIndex]]
+		children = Array.isArray(arguments[childrenIndex]) ? arguments[childrenIndex] : [arguments[childrenIndex]]
 	}
 	else {
 		children = []
diff --git a/render/render.js b/render/render.js
index 516b0c7f..4e993f59 100644
--- a/render/render.js
+++ b/render/render.js
@@ -95,12 +95,7 @@ module.exports = function($window) {
 		return element
 	}
 	function createComponent(vnode, hooks, ns) {
-		// For object literals since `Vnode()` always sets the `state` field.
-		if (!vnode.state) vnode.state = {}
-		var constructor = function() {}
-		constructor.prototype = vnode.tag
-		vnode.state = new constructor
-
+		vnode.state = Object.create(vnode.tag)
 		var view = vnode.tag.view
 		if (view.reentrantLock != null) return $emptyFragment
 		view.reentrantLock = true
@@ -417,7 +412,7 @@ module.exports = function($window) {
 		if (vnode.instance != null) onremove(vnode.instance)
 		else {
 			var children = vnode.children
-			if (children instanceof Array) {
+			if (Array.isArray(children)) {
 				for (var i = 0; i < children.length; i++) {
 					var child = children[i]
 					if (child != null) onremove(child)
@@ -566,7 +561,7 @@ module.exports = function($window) {
 		// First time rendering into a node clears it out
 		if (dom.vnodes == null) dom.textContent = ""
 
-		if (!(vnodes instanceof Array)) vnodes = [vnodes]
+		if (!Array.isArray(vnodes)) vnodes = [vnodes]
 		updateNodes(dom, dom.vnodes, Vnode.normalizeChildren(vnodes), hooks, null, undefined)
 		dom.vnodes = vnodes
 		for (var i = 0; i < hooks.length; i++) hooks[i]()
diff --git a/render/tests/test-component.js b/render/tests/test-component.js
index f4aad629..4bb0a3b6 100644
--- a/render/tests/test-component.js
+++ b/render/tests/test-component.js
@@ -104,7 +104,7 @@ o.spec("component", function() {
 			visible = false
 			render(root, [{tag: component}])
 
-			o(root.firstChild.nodeValue).equals("false")
+			o(root.firstChild.nodeValue).equals("")
 		})
 		o("updates root from null to null", function() {
 			var component = {
@@ -232,7 +232,7 @@ o.spec("component", function() {
 			render(root, [{tag: component}])
 
 			o(root.firstChild.nodeType).equals(3)
-			o(root.firstChild.nodeValue).equals("false")
+			o(root.firstChild.nodeValue).equals("")
 		})
 		o("can return null", function() {
 			var component = {
@@ -668,7 +668,7 @@ o.spec("component", function() {
 			function init(vnode) {
 				o(vnode.state.data).deepEquals(data)
 				o(vnode.state.data).equals(data)
-				
+
 				//inherits state via prototype
 				component.x = 1
 				o(vnode.state.x).equals(1)
diff --git a/render/tests/test-fragment.js b/render/tests/test-fragment.js
index f0403bbc..b10fc850 100644
--- a/render/tests/test-fragment.js
+++ b/render/tests/test-fragment.js
@@ -11,7 +11,7 @@ o.spec("fragment", function() {
 
 		o(frag.tag).equals("[")
 
-		o(frag.children instanceof Array).equals(true)
+		o(Array.isArray(frag.children)).equals(true)
 		o(frag.children.length).equals(1)
 		o(frag.children[0]).equals(child)
 
@@ -24,7 +24,7 @@ o.spec("fragment", function() {
 		var frag = fragment(attrs, [])
 		o(frag.tag).equals("[")
 
-		o(frag.children instanceof Array).equals(true)
+		o(Array.isArray(frag.children)).equals(true)
 		o(frag.children.length).equals(0)
 
 		o(frag.attrs).equals(attrs)
diff --git a/render/tests/test-hyperscript.js b/render/tests/test-hyperscript.js
index 8237d0ea..32e767d8 100644
--- a/render/tests/test-hyperscript.js
+++ b/render/tests/test-hyperscript.js
@@ -229,7 +229,7 @@ o.spec("hyperscript", function() {
 		o("handles falsy boolean single child", function() {
 			var vnode = m("div", {}, [false])
 
-			o(vnode.text).equals(false)
+			o(vnode.text).equals("")
 		})
 		o("handles null single child", function() {
 			var vnode = m("div", {}, [null])
@@ -261,7 +261,7 @@ o.spec("hyperscript", function() {
 			var vnode = m("div", {}, [false, true])
 
 			o(vnode.children[0].tag).equals("#")
-			o(vnode.children[0].children).equals(false)
+			o(vnode.children[0].children).equals("")
 			o(vnode.children[1].tag).equals("#")
 			o(vnode.children[1].children).equals(true)
 		})
@@ -353,10 +353,16 @@ o.spec("hyperscript", function() {
 			o(vnode.text).equals(true)
 		})
 		o("handles attr and single falsy boolean text child", function() {
+			var vnode = m("div", {a: "b"}, [0])
+
+			o(vnode.attrs.a).equals("b")
+			o(vnode.text).equals(0)
+		})
+		o("handles attr and single false boolean text child", function() {
 			var vnode = m("div", {a: "b"}, [false])
 
 			o(vnode.attrs.a).equals("b")
-			o(vnode.text).equals(false)
+			o(vnode.text).equals("")
 		})
 		o("handles attr and single text child unwrapped", function() {
 			var vnode = m("div", {a: "b"}, "c")
diff --git a/render/tests/test-normalize.js b/render/tests/test-normalize.js
index 7a01af31..237612a4 100644
--- a/render/tests/test-normalize.js
+++ b/render/tests/test-normalize.js
@@ -48,10 +48,10 @@ o.spec("normalize", function() {
 		o(node.tag).equals("#")
 		o(node.children).equals(true)
 	})
-	o("normalizes falsy boolean into text node", function() {
+	o("normalizes falsy boolean into empty text node", function() {
 		var node = Vnode.normalize(false)
 
 		o(node.tag).equals("#")
-		o(node.children).equals(false)
+		o(node.children).equals("")
 	})
 })
diff --git a/render/tests/test-normalizeChildren.js b/render/tests/test-normalizeChildren.js
index 9ad2cd89..699f0eab 100644
--- a/render/tests/test-normalizeChildren.js
+++ b/render/tests/test-normalizeChildren.js
@@ -16,4 +16,10 @@ o.spec("normalizeChildren", function() {
 		o(children[0].tag).equals("#")
 		o(children[0].children).equals("a")
 	})
+	o("normalizes `false` values into empty string text nodes", function() {
+		var children = Vnode.normalizeChildren([false])
+
+		o(children[0].tag).equals("#")
+		o(children[0].children).equals("")
+	})
 })
diff --git a/render/tests/test-onbeforeremove.js b/render/tests/test-onbeforeremove.js
index 82a859d0..c9af4894 100644
--- a/render/tests/test-onbeforeremove.js
+++ b/render/tests/test-onbeforeremove.js
@@ -158,14 +158,14 @@ o.spec("onbeforeremove", function() {
 
 		render(root, vnodes)
 		render(root, updated)
-		
+
 		o(root.childNodes.length).equals(2)
 		o(root.firstChild.firstChild.nodeValue).equals("1")
-		
+
 		callAsync(function() {
 			o(root.childNodes.length).equals(1)
 			o(root.firstChild.firstChild.nodeValue).equals("2")
-			
+
 			done()
 		})
 	})
@@ -184,4 +184,25 @@ o.spec("onbeforeremove", function() {
 			done()
 		})
 	})
+	o("awaits promise resolution before removing the node", function(done) {
+		var view = o.spy()
+		var onremove = o.spy()
+		var onbeforeremove = function(){return new Promise(function(resolve){callAsync(resolve)})}
+		var component = {
+			onbeforeremove: onbeforeremove,
+			onremove: onremove,
+			view: view,
+		}
+		render(root, [{tag: component}])
+		render(root, [])
+
+		callAsync(function(){
+			o(onremove.callCount).equals(0)
+
+			callAsync(function() {
+				o(onremove.callCount).equals(1)
+				done()
+			})
+		})
+	})
 })
diff --git a/render/vnode.js b/render/vnode.js
index 0c52d53d..56df8c81 100644
--- a/render/vnode.js
+++ b/render/vnode.js
@@ -2,8 +2,8 @@ function Vnode(tag, key, attrs, children, text, dom) {
 	return {tag: tag, key: key, attrs: attrs, children: children, text: text, dom: dom, domSize: undefined, state: {}, events: undefined, instance: undefined, skip: false}
 }
 Vnode.normalize = function(node) {
-	if (node instanceof Array) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
-	if (node != null && typeof node !== "object") return Vnode("#", undefined, undefined, node, undefined, undefined)
+	if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
+	if (node != null && typeof node !== "object") return Vnode("#", undefined, undefined, node === false ? "" : node, undefined, undefined)
 	return node
 }
 Vnode.normalizeChildren = function normalizeChildren(children) {
diff --git a/request/request.js b/request/request.js
index 11e2e956..123ae1e7 100644
--- a/request/request.js
+++ b/request/request.js
@@ -152,7 +152,7 @@ module.exports = function($window, Promise) {
 
 	function cast(type, data) {
 		if (typeof type === "function") {
-			if (data instanceof Array) {
+			if (Array.isArray(data)) {
 				for (var i = 0; i < data.length; i++) {
 					data[i] = new type(data[i])
 				}
diff --git a/request/tests/test-jsonp.js b/request/tests/test-jsonp.js
index 6dd0a619..7042274c 100644
--- a/request/tests/test-jsonp.js
+++ b/request/tests/test-jsonp.js
@@ -64,17 +64,6 @@ o.spec("jsonp", function() {
 			o(data).deepEquals({a: 2})
 		}).then(done)
 	})
-	o("works w/ custom callbackKey", function(done) {
-		mock.$defineRoutes({
-			"GET /item": function(request) {
-				var queryData = parseQueryString(request.query)
-				return {status: 200, responseText: queryData["cb"] + "(" + JSON.stringify({a: 2}) + ")"}
-			}
-		})
-		jsonp({url: "/item", callbackKey: "cb"}).then(function(data) {
-			o(data).deepEquals({a: 2})
-		}).then(done)
-	})
 	o("requests don't block each other", function(done) {
 		mock.$defineRoutes({
 			"GET /item": function(request) {
diff --git a/test-utils/tests/test-parseURL.js b/test-utils/tests/test-parseURL.js
index 10bb7e81..b722cd8d 100644
--- a/test-utils/tests/test-parseURL.js
+++ b/test-utils/tests/test-parseURL.js
@@ -136,7 +136,7 @@ o.spec("parseURL", function() {
 			o(data.search).equals("?a/c")
 			o(data.hash).equals("")
 		})
-		o("handles search w/ slash", function() {
+		o("handles search w/ colon", function() {
 			var data = parseURL("http://www.google.com/test?a:c")
 			o(data.pathname).equals("/test")
 			o(data.search).equals("?a:c")
diff --git a/test-utils/tests/test-pushStateMock.js b/test-utils/tests/test-pushStateMock.js
index 86298b30..3cb51716 100644
--- a/test-utils/tests/test-pushStateMock.js
+++ b/test-utils/tests/test-pushStateMock.js
@@ -382,12 +382,6 @@ o.spec("pushStateMock", function() {
 
 			o($window.onpopstate.callCount).equals(2)
 		})
-		o("history.back() without history does not trigger onpopstate", function() {
-			$window.onpopstate = o.spy()
-			$window.history.back()
-
-			o($window.onpopstate.callCount).equals(0)
-		})
 		o("history.forward() without history does not trigger onpopstate", function() {
 			$window.onpopstate = o.spy()
 			$window.history.forward()
diff --git a/test-utils/xhrMock.js b/test-utils/xhrMock.js
index 0a7b8f8d..37d48e92 100644
--- a/test-utils/xhrMock.js
+++ b/test-utils/xhrMock.js
@@ -7,8 +7,8 @@ var parseQueryString = require("../querystring/parse")
 module.exports = function() {
 	var routes = {}
 	var callback = "callback"
-	var serverErrorHandler = function() {
-		return {status: 500, responseText: "server error, most likely the URL was not defined"}
+	var serverErrorHandler = function(url) {
+		return {status: 500, responseText: "server error, most likely the URL was not defined " + url}
 	}
 
 	var $window = {
@@ -32,7 +32,7 @@ module.exports = function() {
 			}
 			this.send = function(body) {
 				var self = this
-				var handler = routes[args.method + " " + args.pathname] || serverErrorHandler
+				var handler = routes[args.method + " " + args.pathname] || serverErrorHandler.bind(null, args.pathname)
 				var data = handler({url: args.pathname, query: args.search || {}, body: body || null})
 				self.readyState = 4
 				self.status = data.status
@@ -54,7 +54,7 @@ module.exports = function() {
 					element.parentNode = this
 					if (element.nodeName === "SCRIPT") {
 						var urlData = parseURL(element.src, {protocol: "http:", hostname: "localhost", port: "", pathname: "/"})
-						var handler = routes["GET " + urlData.pathname] || serverErrorHandler
+						var handler = routes["GET " + urlData.pathname] || serverErrorHandler.bind(null, element.src)
 						var data = handler({url: urlData.pathname, query: urlData.search, body: null})
 						var query = parseQueryString(urlData.search)
 						callAsync(function() {