(function (cache, modules) {
  function require(i) { return cache[i] || get(i); }
  function get(i) {
    var exports = {}, module = {exports: exports};
    modules[i].call(exports, window, require, module, exports);
    return (cache[i] = module.exports);
  }
  var main = require(0);
  return main.__esModule ? main.default : main;
}([],[function (global, require, module, exports) {
// index.js
const m = require(1)
const Authentication = require(26)
const AdminResolver = require(27)
const Header = require(28)
const Footer = require(31)
const Login = require(32)
const SitePage = require(33)
const SiteArticle = require(41)
const NotFoundView = require(40)
window.m = m

m.route.setOrig = m.route.set
m.route.set = function(path, data, options){
  m.route.setOrig(path, data, options)
  window.scrollTo(0, 0)
}

m.route.linkOrig = m.route.link
m.route.link = function(vnode){
  m.route.linkOrig(vnode)
  window.scrollTo(0, 0)
}

m.route.prefix = ''

const allRoutes = {
  '/': SitePage, // Frontpage
  '/login': Login,
  '/page/:id': SitePage,
  '/article/:id': SiteArticle,
  '/admin/:path': AdminResolver,
  '/admin/:path/:id': AdminResolver,
  '/:404...': NotFoundView,
}

// Wait until we finish checking avif support, some views render immediately and will ask for this immediately before the callback gets called.

/*
 * imgsupport.js from leechy/imgsupport 
 */
const AVIF = new Image();
AVIF.onload = AVIF.onerror = function () {
  window.supportsavif = (AVIF.height === 2)
  document.body.className = document.body.className + ' ' + (window.supportsavif ? 'avifsupport' : 'jpegonly')

  m.mount(document.getElementById('header'), Header)
  m.route(document.getElementById('main'), '/', allRoutes)
  m.mount(document.getElementById('footer'), Footer)
}
AVIF.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAABAA0ABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgAPkgIaDQgMgkf8AAAQAAAr3A=';

},function (global, require, module, exports) {
// ../node_modules/mithril/index.js
"use strict"

var hyperscript = require(2)
var request = require(9)
var mountRedraw = require(12)

var m = function m() { return hyperscript.apply(this, arguments) }
m.m = hyperscript
m.trust = hyperscript.trust
m.fragment = hyperscript.fragment
m.Fragment = "["
m.mount = mountRedraw.mount
m.route = require(20)
m.render = require(13)
m.redraw = mountRedraw.redraw
m.request = request.request
m.jsonp = request.jsonp
m.parseQueryString = require(23)
m.buildQueryString = require(18)
m.parsePathname = require(22)
m.buildPathname = require(17)
m.vnode = require(4)
m.PromisePolyfill = require(11)
m.censor = require(25)

module.exports = m

},function (global, require, module, exports) {
// ../node_modules/mithril/hyperscript.js
"use strict"

var hyperscript = require(3)

hyperscript.trust = require(7)
hyperscript.fragment = require(8)

module.exports = hyperscript

},function (global, require, module, exports) {
// ../node_modules/mithril/render/hyperscript.js
"use strict"

var Vnode = require(4)
var hyperscriptVnode = require(5)
var hasOwn = require(6)

var selectorParser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g
var selectorCache = {}

function isEmpty(object) {
	for (var key in object) if (hasOwn.call(object, key)) return false
	return true
}

function compileSelector(selector) {
	var match, tag = "div", classes = [], attrs = {}
	while (match = selectorParser.exec(selector)) {
		var type = match[1], value = match[2]
		if (type === "" && value !== "") tag = value
		else if (type === "#") attrs.id = value
		else if (type === ".") classes.push(value)
		else if (match[3][0] === "[") {
			var attrValue = match[6]
			if (attrValue) attrValue = attrValue.replace(/\\(["'])/g, "$1").replace(/\\\\/g, "\\")
			if (match[4] === "class") classes.push(attrValue)
			else attrs[match[4]] = attrValue === "" ? attrValue : attrValue || true
		}
	}
	if (classes.length > 0) attrs.className = classes.join(" ")
	return selectorCache[selector] = {tag: tag, attrs: attrs}
}

function execSelector(state, vnode) {
	var attrs = vnode.attrs
	var hasClass = hasOwn.call(attrs, "class")
	var className = hasClass ? attrs.class : attrs.className

	vnode.tag = state.tag
	vnode.attrs = {}

	if (!isEmpty(state.attrs) && !isEmpty(attrs)) {
		var newAttrs = {}

		for (var key in attrs) {
			if (hasOwn.call(attrs, key)) newAttrs[key] = attrs[key]
		}

		attrs = newAttrs
	}

	for (var key in state.attrs) {
		if (hasOwn.call(state.attrs, key) && key !== "className" && !hasOwn.call(attrs, key)){
			attrs[key] = state.attrs[key]
		}
	}
	if (className != null || state.attrs.className != null) attrs.className =
		className != null
			? state.attrs.className != null
				? String(state.attrs.className) + " " + String(className)
				: className
			: state.attrs.className != null
				? state.attrs.className
				: null

	if (hasClass) attrs.class = null

	for (var key in attrs) {
		if (hasOwn.call(attrs, key) && key !== "key") {
			vnode.attrs = attrs
			break
		}
	}

	return vnode
}

function hyperscript(selector) {
	if (selector == null || typeof selector !== "string" && typeof selector !== "function" && typeof selector.view !== "function") {
		throw Error("The selector must be either a string or a component.");
	}

	var vnode = hyperscriptVnode.apply(1, arguments)

	if (typeof selector === "string") {
		vnode.children = Vnode.normalizeChildren(vnode.children)
		if (selector !== "[") return execSelector(selectorCache[selector] || compileSelector(selector), vnode)
	}

	vnode.tag = selector
	return vnode
}

module.exports = hyperscript

},function (global, require, module, exports) {
// ../node_modules/mithril/render/vnode.js
"use strict"

function Vnode(tag, key, attrs, children, text, dom) {
	return {tag: tag, key: key, attrs: attrs, children: children, text: text, dom: dom, domSize: undefined, state: undefined, events: undefined, instance: undefined}
}
Vnode.normalize = function(node) {
	if (Array.isArray(node)) return Vnode("[", undefined, undefined, Vnode.normalizeChildren(node), undefined, undefined)
	if (node == null || typeof node === "boolean") return null
	if (typeof node === "object") return node
	return Vnode("#", undefined, undefined, String(node), undefined, undefined)
}
Vnode.normalizeChildren = function(input) {
	var children = []
	if (input.length) {
		var isKeyed = input[0] != null && input[0].key != null
		// Note: this is a *very* perf-sensitive check.
		// Fun fact: merging the loop like this is somehow faster than splitting
		// it, noticeably so.
		for (var i = 1; i < input.length; i++) {
			if ((input[i] != null && input[i].key != null) !== isKeyed) {
				throw new TypeError(
					isKeyed && (input[i] != null || typeof input[i] === "boolean")
						? "In fragments, vnodes must either all have keys or none have keys. You may wish to consider using an explicit keyed empty fragment, m.fragment({key: ...}), instead of a hole."
						: "In fragments, vnodes must either all have keys or none have keys."
				)
			}
		}
		for (var i = 0; i < input.length; i++) {
			children[i] = Vnode.normalize(input[i])
		}
	}
	return children
}

module.exports = Vnode

},function (global, require, module, exports) {
// ../node_modules/mithril/render/hyperscriptVnode.js
"use strict"

var Vnode = require(4)

// Call via `hyperscriptVnode.apply(startOffset, arguments)`
//
// The reason I do it this way, forwarding the arguments and passing the start
// offset in `this`, is so I don't have to create a temporary array in a
// performance-critical path.
//
// In native ES6, I'd instead add a final `...args` parameter to the
// `hyperscript` and `fragment` factories and define this as
// `hyperscriptVnode(...args)`, since modern engines do optimize that away. But
// ES5 (what Mithril.js requires thanks to IE support) doesn't give me that luxury,
// and engines aren't nearly intelligent enough to do either of these:
//
// 1. Elide the allocation for `[].slice.call(arguments, 1)` when it's passed to
//    another function only to be indexed.
// 2. Elide an `arguments` allocation when it's passed to any function other
//    than `Function.prototype.apply` or `Reflect.apply`.
//
// In ES6, it'd probably look closer to this (I'd need to profile it, though):
// module.exports = function(attrs, ...children) {
//     if (attrs == null || typeof attrs === "object" && attrs.tag == null && !Array.isArray(attrs)) {
//         if (children.length === 1 && Array.isArray(children[0])) children = children[0]
//     } else {
//         children = children.length === 0 && Array.isArray(attrs) ? attrs : [attrs, ...children]
//         attrs = undefined
//     }
//
//     if (attrs == null) attrs = {}
//     return Vnode("", attrs.key, attrs, children)
// }
module.exports = function() {
	var attrs = arguments[this], start = this + 1, children

	if (attrs == null) {
		attrs = {}
	} else if (typeof attrs !== "object" || attrs.tag != null || Array.isArray(attrs)) {
		attrs = {}
		start = this
	}

	if (arguments.length === start + 1) {
		children = arguments[start]
		if (!Array.isArray(children)) children = [children]
	} else {
		children = []
		while (start < arguments.length) children.push(arguments[start++])
	}

	return Vnode("", attrs.key, attrs, children)
}

},function (global, require, module, exports) {
// ../node_modules/mithril/util/hasOwn.js
// This exists so I'm only saving it once.
"use strict"

module.exports = {}.hasOwnProperty

},function (global, require, module, exports) {
// ../node_modules/mithril/render/trust.js
"use strict"

var Vnode = require(4)

module.exports = function(html) {
	if (html == null) html = ""
	return Vnode("<", undefined, undefined, html, undefined, undefined)
}

},function (global, require, module, exports) {
// ../node_modules/mithril/render/fragment.js
"use strict"

var Vnode = require(4)
var hyperscriptVnode = require(5)

module.exports = function() {
	var vnode = hyperscriptVnode.apply(0, arguments)

	vnode.tag = "["
	vnode.children = Vnode.normalizeChildren(vnode.children)
	return vnode
}

},function (global, require, module, exports) {
// ../node_modules/mithril/request.js
"use strict"

var PromisePolyfill = require(10)
var mountRedraw = require(12)

module.exports = require(16)(typeof window !== "undefined" ? window : null, PromisePolyfill, mountRedraw.redraw)

},function (global, require, module, exports) {
// ../node_modules/mithril/promise/promise.js
/* global window */
"use strict"

var PromisePolyfill = require(11)

if (typeof window !== "undefined") {
	if (typeof window.Promise === "undefined") {
		window.Promise = PromisePolyfill
	} else if (!window.Promise.prototype.finally) {
		window.Promise.prototype.finally = PromisePolyfill.prototype.finally
	}
	module.exports = window.Promise
} else if (typeof global !== "undefined") {
	if (typeof global.Promise === "undefined") {
		global.Promise = PromisePolyfill
	} else if (!global.Promise.prototype.finally) {
		global.Promise.prototype.finally = PromisePolyfill.prototype.finally
	}
	module.exports = global.Promise
} else {
	module.exports = PromisePolyfill
}

},function (global, require, module, exports) {
// ../node_modules/mithril/promise/polyfill.js
"use strict"
/** @constructor */
var PromisePolyfill = function(executor) {
	if (!(this instanceof PromisePolyfill)) throw new Error("Promise must be called with 'new'.")
	if (typeof executor !== "function") throw new TypeError("executor must be a function.")

	var self = this, resolvers = [], rejectors = [], resolveCurrent = handler(resolvers, true), rejectCurrent = handler(rejectors, false)
	var instance = self._instance = {resolvers: resolvers, rejectors: rejectors}
	var callAsync = typeof setImmediate === "function" ? setImmediate : setTimeout
	function handler(list, shouldAbsorb) {
		return function execute(value) {
			var then
			try {
				if (shouldAbsorb && value != null && (typeof value === "object" || typeof value === "function") && typeof (then = value.then) === "function") {
					if (value === self) throw new TypeError("Promise can't be resolved with itself.")
					executeOnce(then.bind(value))
				}
				else {
					callAsync(function() {
						if (!shouldAbsorb && list.length === 0) console.error("Possible unhandled promise rejection:", value)
						for (var i = 0; i < list.length; i++) list[i](value)
						resolvers.length = 0, rejectors.length = 0
						instance.state = shouldAbsorb
						instance.retry = function() {execute(value)}
					})
				}
			}
			catch (e) {
				rejectCurrent(e)
			}
		}
	}
	function executeOnce(then) {
		var runs = 0
		function run(fn) {
			return function(value) {
				if (runs++ > 0) return
				fn(value)
			}
		}
		var onerror = run(rejectCurrent)
		try {then(run(resolveCurrent), onerror)} catch (e) {onerror(e)}
	}

	executeOnce(executor)
}
PromisePolyfill.prototype.then = function(onFulfilled, onRejection) {
	var self = this, instance = self._instance
	function handle(callback, list, next, state) {
		list.push(function(value) {
			if (typeof callback !== "function") next(value)
			else try {resolveNext(callback(value))} catch (e) {if (rejectNext) rejectNext(e)}
		})
		if (typeof instance.retry === "function" && state === instance.state) instance.retry()
	}
	var resolveNext, rejectNext
	var promise = new PromisePolyfill(function(resolve, reject) {resolveNext = resolve, rejectNext = reject})
	handle(onFulfilled, instance.resolvers, resolveNext, true), handle(onRejection, instance.rejectors, rejectNext, false)
	return promise
}
PromisePolyfill.prototype.catch = function(onRejection) {
	return this.then(null, onRejection)
}
PromisePolyfill.prototype.finally = function(callback) {
	return this.then(
		function(value) {
			return PromisePolyfill.resolve(callback()).then(function() {
				return value
			})
		},
		function(reason) {
			return PromisePolyfill.resolve(callback()).then(function() {
				return PromisePolyfill.reject(reason);
			})
		}
	)
}
PromisePolyfill.resolve = function(value) {
	if (value instanceof PromisePolyfill) return value
	return new PromisePolyfill(function(resolve) {resolve(value)})
}
PromisePolyfill.reject = function(value) {
	return new PromisePolyfill(function(resolve, reject) {reject(value)})
}
PromisePolyfill.all = function(list) {
	return new PromisePolyfill(function(resolve, reject) {
		var total = list.length, count = 0, values = []
		if (list.length === 0) resolve([])
		else for (var i = 0; i < list.length; i++) {
			(function(i) {
				function consume(value) {
					count++
					values[i] = value
					if (count === total) resolve(values)
				}
				if (list[i] != null && (typeof list[i] === "object" || typeof list[i] === "function") && typeof list[i].then === "function") {
					list[i].then(consume, reject)
				}
				else consume(list[i])
			})(i)
		}
	})
}
PromisePolyfill.race = function(list) {
	return new PromisePolyfill(function(resolve, reject) {
		for (var i = 0; i < list.length; i++) {
			list[i].then(resolve, reject)
		}
	})
}

module.exports = PromisePolyfill

},function (global, require, module, exports) {
// ../node_modules/mithril/mount-redraw.js
"use strict"

var render = require(13)

module.exports = require(15)(render, typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : null, typeof console !== "undefined" ? console : null)

},function (global, require, module, exports) {
// ../node_modules/mithril/render.js
"use strict"

module.exports = require(14)(typeof window !== "undefined" ? window : null)

},function (global, require, module, exports) {
// ../node_modules/mithril/render/render.js
"use strict"

var Vnode = require(4)

module.exports = function($window) {
	var $doc = $window && $window.document
	var currentRedraw

	var nameSpace = {
		svg: "http://www.w3.org/2000/svg",
		math: "http://www.w3.org/1998/Math/MathML"
	}

	function getNameSpace(vnode) {
		return vnode.attrs && vnode.attrs.xmlns || nameSpace[vnode.tag]
	}

	//sanity check to discourage people from doing `vnode.state = ...`
	function checkState(vnode, original) {
		if (vnode.state !== original) throw new Error("'vnode.state' must not be modified.")
	}

	//Note: the hook is passed as the `this` argument to allow proxying the
	//arguments without requiring a full array allocation to do so. It also
	//takes advantage of the fact the current `vnode` is the first argument in
	//all lifecycle methods.
	function callHook(vnode) {
		var original = vnode.state
		try {
			return this.apply(original, arguments)
		} finally {
			checkState(vnode, original)
		}
	}

	// IE11 (at least) throws an UnspecifiedError when accessing document.activeElement when
	// inside an iframe. Catch and swallow this error, and heavy-handidly return null.
	function activeElement() {
		try {
			return $doc.activeElement
		} catch (e) {
			return null
		}
	}
	//create
	function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) {
		for (var i = start; i < end; i++) {
			var vnode = vnodes[i]
			if (vnode != null) {
				createNode(parent, vnode, hooks, ns, nextSibling)
			}
		}
	}
	function createNode(parent, vnode, hooks, ns, nextSibling) {
		var tag = vnode.tag
		if (typeof tag === "string") {
			vnode.state = {}
			if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)
			switch (tag) {
				case "#": createText(parent, vnode, nextSibling); break
				case "<": createHTML(parent, vnode, ns, nextSibling); break
				case "[": createFragment(parent, vnode, hooks, ns, nextSibling); break
				default: createElement(parent, vnode, hooks, ns, nextSibling)
			}
		}
		else createComponent(parent, vnode, hooks, ns, nextSibling)
	}
	function createText(parent, vnode, nextSibling) {
		vnode.dom = $doc.createTextNode(vnode.children)
		insertNode(parent, vnode.dom, nextSibling)
	}
	var possibleParents = {caption: "table", thead: "table", tbody: "table", tfoot: "table", tr: "tbody", th: "tr", td: "tr", colgroup: "table", col: "colgroup"}
	function createHTML(parent, vnode, ns, nextSibling) {
		var match = vnode.children.match(/^\s*?<(\w+)/im) || []
		// not using the proper parent makes the child element(s) vanish.
		//     var div = document.createElement("div")
		//     div.innerHTML = "<td>i</td><td>j</td>"
		//     console.log(div.innerHTML)
		// --> "ij", no <td> in sight.
		var temp = $doc.createElement(possibleParents[match[1]] || "div")
		if (ns === "http://www.w3.org/2000/svg") {
			temp.innerHTML = "<svg xmlns=\"http://www.w3.org/2000/svg\">" + vnode.children + "</svg>"
			temp = temp.firstChild
		} else {
			temp.innerHTML = vnode.children
		}
		vnode.dom = temp.firstChild
		vnode.domSize = temp.childNodes.length
		// Capture nodes to remove, so we don't confuse them.
		vnode.instance = []
		var fragment = $doc.createDocumentFragment()
		var child
		while (child = temp.firstChild) {
			vnode.instance.push(child)
			fragment.appendChild(child)
		}
		insertNode(parent, fragment, nextSibling)
	}
	function createFragment(parent, vnode, hooks, ns, nextSibling) {
		var fragment = $doc.createDocumentFragment()
		if (vnode.children != null) {
			var children = vnode.children
			createNodes(fragment, children, 0, children.length, hooks, null, ns)
		}
		vnode.dom = fragment.firstChild
		vnode.domSize = fragment.childNodes.length
		insertNode(parent, fragment, nextSibling)
	}
	function createElement(parent, vnode, hooks, ns, nextSibling) {
		var tag = vnode.tag
		var attrs = vnode.attrs
		var is = attrs && attrs.is

		ns = getNameSpace(vnode) || ns

		var element = ns ?
			is ? $doc.createElementNS(ns, tag, {is: is}) : $doc.createElementNS(ns, tag) :
			is ? $doc.createElement(tag, {is: is}) : $doc.createElement(tag)
		vnode.dom = element

		if (attrs != null) {
			setAttrs(vnode, attrs, ns)
		}

		insertNode(parent, element, nextSibling)

		if (!maybeSetContentEditable(vnode)) {
			if (vnode.children != null) {
				var children = vnode.children
				createNodes(element, children, 0, children.length, hooks, null, ns)
				if (vnode.tag === "select" && attrs != null) setLateSelectAttrs(vnode, attrs)
			}
		}
	}
	function initComponent(vnode, hooks) {
		var sentinel
		if (typeof vnode.tag.view === "function") {
			vnode.state = Object.create(vnode.tag)
			sentinel = vnode.state.view
			if (sentinel.$$reentrantLock$$ != null) return
			sentinel.$$reentrantLock$$ = true
		} else {
			vnode.state = void 0
			sentinel = vnode.tag
			if (sentinel.$$reentrantLock$$ != null) return
			sentinel.$$reentrantLock$$ = true
			vnode.state = (vnode.tag.prototype != null && typeof vnode.tag.prototype.view === "function") ? new vnode.tag(vnode) : vnode.tag(vnode)
		}
		initLifecycle(vnode.state, vnode, hooks)
		if (vnode.attrs != null) initLifecycle(vnode.attrs, vnode, hooks)
		vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
		if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
		sentinel.$$reentrantLock$$ = null
	}
	function createComponent(parent, vnode, hooks, ns, nextSibling) {
		initComponent(vnode, hooks)
		if (vnode.instance != null) {
			createNode(parent, vnode.instance, hooks, ns, nextSibling)
			vnode.dom = vnode.instance.dom
			vnode.domSize = vnode.dom != null ? vnode.instance.domSize : 0
		}
		else {
			vnode.domSize = 0
		}
	}

	//update
	/**
	 * @param {Element|Fragment} parent - the parent element
	 * @param {Vnode[] | null} old - the list of vnodes of the last `render()` call for
	 *                               this part of the tree
	 * @param {Vnode[] | null} vnodes - as above, but for the current `render()` call.
	 * @param {Function[]} hooks - an accumulator of post-render hooks (oncreate/onupdate)
	 * @param {Element | null} nextSibling - the next DOM node if we're dealing with a
	 *                                       fragment that is not the last item in its
	 *                                       parent
	 * @param {'svg' | 'math' | String | null} ns) - the current XML namespace, if any
	 * @returns void
	 */
	// This function diffs and patches lists of vnodes, both keyed and unkeyed.
	//
	// We will:
	//
	// 1. describe its general structure
	// 2. focus on the diff algorithm optimizations
	// 3. discuss DOM node operations.

	// ## Overview:
	//
	// The updateNodes() function:
	// - deals with trivial cases
	// - determines whether the lists are keyed or unkeyed based on the first non-null node
	//   of each list.
	// - diffs them and patches the DOM if needed (that's the brunt of the code)
	// - manages the leftovers: after diffing, are there:
	//   - old nodes left to remove?
	// 	 - new nodes to insert?
	// 	 deal with them!
	//
	// The lists are only iterated over once, with an exception for the nodes in `old` that
	// are visited in the fourth part of the diff and in the `removeNodes` loop.

	// ## Diffing
	//
	// Reading https://github.com/localvoid/ivi/blob/ddc09d06abaef45248e6133f7040d00d3c6be853/packages/ivi/src/vdom/implementation.ts#L617-L837
	// may be good for context on longest increasing subsequence-based logic for moving nodes.
	//
	// In order to diff keyed lists, one has to
	//
	// 1) match nodes in both lists, per key, and update them accordingly
	// 2) create the nodes present in the new list, but absent in the old one
	// 3) remove the nodes present in the old list, but absent in the new one
	// 4) figure out what nodes in 1) to move in order to minimize the DOM operations.
	//
	// To achieve 1) one can create a dictionary of keys => index (for the old list), then iterate
	// over the new list and for each new vnode, find the corresponding vnode in the old list using
	// the map.
	// 2) is achieved in the same step: if a new node has no corresponding entry in the map, it is new
	// and must be created.
	// For the removals, we actually remove the nodes that have been updated from the old list.
	// The nodes that remain in that list after 1) and 2) have been performed can be safely removed.
	// The fourth step is a bit more complex and relies on the longest increasing subsequence (LIS)
	// algorithm.
	//
	// the longest increasing subsequence is the list of nodes that can remain in place. Imagine going
	// from `1,2,3,4,5` to `4,5,1,2,3` where the numbers are not necessarily the keys, but the indices
	// corresponding to the keyed nodes in the old list (keyed nodes `e,d,c,b,a` => `b,a,e,d,c` would
	//  match the above lists, for example).
	//
	// In there are two increasing subsequences: `4,5` and `1,2,3`, the latter being the longest. We
	// can update those nodes without moving them, and only call `insertNode` on `4` and `5`.
	//
	// @localvoid adapted the algo to also support node deletions and insertions (the `lis` is actually
	// the longest increasing subsequence *of old nodes still present in the new list*).
	//
	// It is a general algorithm that is fireproof in all circumstances, but it requires the allocation
	// and the construction of a `key => oldIndex` map, and three arrays (one with `newIndex => oldIndex`,
	// the `LIS` and a temporary one to create the LIS).
	//
	// So we cheat where we can: if the tails of the lists are identical, they are guaranteed to be part of
	// the LIS and can be updated without moving them.
	//
	// If two nodes are swapped, they are guaranteed not to be part of the LIS, and must be moved (with
	// the exception of the last node if the list is fully reversed).
	//
	// ## Finding the next sibling.
	//
	// `updateNode()` and `createNode()` expect a nextSibling parameter to perform DOM operations.
	// When the list is being traversed top-down, at any index, the DOM nodes up to the previous
	// vnode reflect the content of the new list, whereas the rest of the DOM nodes reflect the old
	// list. The next sibling must be looked for in the old list using `getNextSibling(... oldStart + 1 ...)`.
	//
	// In the other scenarios (swaps, upwards traversal, map-based diff),
	// the new vnodes list is traversed upwards. The DOM nodes at the bottom of the list reflect the
	// bottom part of the new vnodes list, and we can use the `v.dom`  value of the previous node
	// as the next sibling (cached in the `nextSibling` variable).


	// ## DOM node moves
	//
	// In most scenarios `updateNode()` and `createNode()` perform the DOM operations. However,
	// this is not the case if the node moved (second and fourth part of the diff algo). We move
	// the old DOM nodes before updateNode runs because it enables us to use the cached `nextSibling`
	// variable rather than fetching it using `getNextSibling()`.
	//
	// The fourth part of the diff currently inserts nodes unconditionally, leading to issues
	// like #1791 and #1999. We need to be smarter about those situations where adjascent old
	// nodes remain together in the new list in a way that isn't covered by parts one and
	// three of the diff algo.

	function updateNodes(parent, old, vnodes, hooks, nextSibling, ns) {
		if (old === vnodes || old == null && vnodes == null) return
		else if (old == null || old.length === 0) createNodes(parent, vnodes, 0, vnodes.length, hooks, nextSibling, ns)
		else if (vnodes == null || vnodes.length === 0) removeNodes(parent, old, 0, old.length)
		else {
			var isOldKeyed = old[0] != null && old[0].key != null
			var isKeyed = vnodes[0] != null && vnodes[0].key != null
			var start = 0, oldStart = 0
			if (!isOldKeyed) while (oldStart < old.length && old[oldStart] == null) oldStart++
			if (!isKeyed) while (start < vnodes.length && vnodes[start] == null) start++
			if (isOldKeyed !== isKeyed) {
				removeNodes(parent, old, oldStart, old.length)
				createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns)
			} else if (!isKeyed) {
				// Don't index past the end of either list (causes deopts).
				var commonLength = old.length < vnodes.length ? old.length : vnodes.length
				// Rewind if necessary to the first non-null index on either side.
				// We could alternatively either explicitly create or remove nodes when `start !== oldStart`
				// but that would be optimizing for sparse lists which are more rare than dense ones.
				start = start < oldStart ? start : oldStart
				for (; start < commonLength; start++) {
					o = old[start]
					v = vnodes[start]
					if (o === v || o == null && v == null) continue
					else if (o == null) createNode(parent, v, hooks, ns, getNextSibling(old, start + 1, nextSibling))
					else if (v == null) removeNode(parent, o)
					else updateNode(parent, o, v, hooks, getNextSibling(old, start + 1, nextSibling), ns)
				}
				if (old.length > commonLength) removeNodes(parent, old, start, old.length)
				if (vnodes.length > commonLength) createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns)
			} else {
				// keyed diff
				var oldEnd = old.length - 1, end = vnodes.length - 1, map, o, v, oe, ve, topSibling

				// bottom-up
				while (oldEnd >= oldStart && end >= start) {
					oe = old[oldEnd]
					ve = vnodes[end]
					if (oe.key !== ve.key) break
					if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)
					if (ve.dom != null) nextSibling = ve.dom
					oldEnd--, end--
				}
				// top-down
				while (oldEnd >= oldStart && end >= start) {
					o = old[oldStart]
					v = vnodes[start]
					if (o.key !== v.key) break
					oldStart++, start++
					if (o !== v) updateNode(parent, o, v, hooks, getNextSibling(old, oldStart, nextSibling), ns)
				}
				// swaps and list reversals
				while (oldEnd >= oldStart && end >= start) {
					if (start === end) break
					if (o.key !== ve.key || oe.key !== v.key) break
					topSibling = getNextSibling(old, oldStart, nextSibling)
					moveNodes(parent, oe, topSibling)
					if (oe !== v) updateNode(parent, oe, v, hooks, topSibling, ns)
					if (++start <= --end) moveNodes(parent, o, nextSibling)
					if (o !== ve) updateNode(parent, o, ve, hooks, nextSibling, ns)
					if (ve.dom != null) nextSibling = ve.dom
					oldStart++; oldEnd--
					oe = old[oldEnd]
					ve = vnodes[end]
					o = old[oldStart]
					v = vnodes[start]
				}
				// bottom up once again
				while (oldEnd >= oldStart && end >= start) {
					if (oe.key !== ve.key) break
					if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)
					if (ve.dom != null) nextSibling = ve.dom
					oldEnd--, end--
					oe = old[oldEnd]
					ve = vnodes[end]
				}
				if (start > end) removeNodes(parent, old, oldStart, oldEnd + 1)
				else if (oldStart > oldEnd) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)
				else {
					// inspired by ivi https://github.com/ivijs/ivi/ by Boris Kaul
					var originalNextSibling = nextSibling, vnodesLength = end - start + 1, oldIndices = new Array(vnodesLength), li=0, i=0, pos = 2147483647, matched = 0, map, lisIndices
					for (i = 0; i < vnodesLength; i++) oldIndices[i] = -1
					for (i = end; i >= start; i--) {
						if (map == null) map = getKeyMap(old, oldStart, oldEnd + 1)
						ve = vnodes[i]
						var oldIndex = map[ve.key]
						if (oldIndex != null) {
							pos = (oldIndex < pos) ? oldIndex : -1 // becomes -1 if nodes were re-ordered
							oldIndices[i-start] = oldIndex
							oe = old[oldIndex]
							old[oldIndex] = null
							if (oe !== ve) updateNode(parent, oe, ve, hooks, nextSibling, ns)
							if (ve.dom != null) nextSibling = ve.dom
							matched++
						}
					}
					nextSibling = originalNextSibling
					if (matched !== oldEnd - oldStart + 1) removeNodes(parent, old, oldStart, oldEnd + 1)
					if (matched === 0) createNodes(parent, vnodes, start, end + 1, hooks, nextSibling, ns)
					else {
						if (pos === -1) {
							// the indices of the indices of the items that are part of the
							// longest increasing subsequence in the oldIndices list
							lisIndices = makeLisIndices(oldIndices)
							li = lisIndices.length - 1
							for (i = end; i >= start; i--) {
								v = vnodes[i]
								if (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling)
								else {
									if (lisIndices[li] === i - start) li--
									else moveNodes(parent, v, nextSibling)
								}
								if (v.dom != null) nextSibling = vnodes[i].dom
							}
						} else {
							for (i = end; i >= start; i--) {
								v = vnodes[i]
								if (oldIndices[i-start] === -1) createNode(parent, v, hooks, ns, nextSibling)
								if (v.dom != null) nextSibling = vnodes[i].dom
							}
						}
					}
				}
			}
		}
	}
	function updateNode(parent, old, vnode, hooks, nextSibling, ns) {
		var oldTag = old.tag, tag = vnode.tag
		if (oldTag === tag) {
			vnode.state = old.state
			vnode.events = old.events
			if (shouldNotUpdate(vnode, old)) return
			if (typeof oldTag === "string") {
				if (vnode.attrs != null) {
					updateLifecycle(vnode.attrs, vnode, hooks)
				}
				switch (oldTag) {
					case "#": updateText(old, vnode); break
					case "<": updateHTML(parent, old, vnode, ns, nextSibling); break
					case "[": updateFragment(parent, old, vnode, hooks, nextSibling, ns); break
					default: updateElement(old, vnode, hooks, ns)
				}
			}
			else updateComponent(parent, old, vnode, hooks, nextSibling, ns)
		}
		else {
			removeNode(parent, old)
			createNode(parent, vnode, hooks, ns, nextSibling)
		}
	}
	function updateText(old, vnode) {
		if (old.children.toString() !== vnode.children.toString()) {
			old.dom.nodeValue = vnode.children
		}
		vnode.dom = old.dom
	}
	function updateHTML(parent, old, vnode, ns, nextSibling) {
		if (old.children !== vnode.children) {
			removeHTML(parent, old)
			createHTML(parent, vnode, ns, nextSibling)
		}
		else {
			vnode.dom = old.dom
			vnode.domSize = old.domSize
			vnode.instance = old.instance
		}
	}
	function updateFragment(parent, old, vnode, hooks, nextSibling, ns) {
		updateNodes(parent, old.children, vnode.children, hooks, nextSibling, ns)
		var domSize = 0, children = vnode.children
		vnode.dom = null
		if (children != null) {
			for (var i = 0; i < children.length; i++) {
				var child = children[i]
				if (child != null && child.dom != null) {
					if (vnode.dom == null) vnode.dom = child.dom
					domSize += child.domSize || 1
				}
			}
			if (domSize !== 1) vnode.domSize = domSize
		}
	}
	function updateElement(old, vnode, hooks, ns) {
		var element = vnode.dom = old.dom
		ns = getNameSpace(vnode) || ns

		if (vnode.tag === "textarea") {
			if (vnode.attrs == null) vnode.attrs = {}
		}
		updateAttrs(vnode, old.attrs, vnode.attrs, ns)
		if (!maybeSetContentEditable(vnode)) {
			updateNodes(element, old.children, vnode.children, hooks, null, ns)
		}
	}
	function updateComponent(parent, old, vnode, hooks, nextSibling, ns) {
		vnode.instance = Vnode.normalize(callHook.call(vnode.state.view, vnode))
		if (vnode.instance === vnode) throw Error("A view cannot return the vnode it received as argument")
		updateLifecycle(vnode.state, vnode, hooks)
		if (vnode.attrs != null) updateLifecycle(vnode.attrs, vnode, hooks)
		if (vnode.instance != null) {
			if (old.instance == null) createNode(parent, vnode.instance, hooks, ns, nextSibling)
			else updateNode(parent, old.instance, vnode.instance, hooks, nextSibling, ns)
			vnode.dom = vnode.instance.dom
			vnode.domSize = vnode.instance.domSize
		}
		else if (old.instance != null) {
			removeNode(parent, old.instance)
			vnode.dom = undefined
			vnode.domSize = 0
		}
		else {
			vnode.dom = old.dom
			vnode.domSize = old.domSize
		}
	}
	function getKeyMap(vnodes, start, end) {
		var map = Object.create(null)
		for (; start < end; start++) {
			var vnode = vnodes[start]
			if (vnode != null) {
				var key = vnode.key
				if (key != null) map[key] = start
			}
		}
		return map
	}
	// Lifted from ivi https://github.com/ivijs/ivi/
	// takes a list of unique numbers (-1 is special and can
	// occur multiple times) and returns an array with the indices
	// of the items that are part of the longest increasing
	// subsequence
	var lisTemp = []
	function makeLisIndices(a) {
		var result = [0]
		var u = 0, v = 0, i = 0
		var il = lisTemp.length = a.length
		for (var i = 0; i < il; i++) lisTemp[i] = a[i]
		for (var i = 0; i < il; ++i) {
			if (a[i] === -1) continue
			var j = result[result.length - 1]
			if (a[j] < a[i]) {
				lisTemp[i] = j
				result.push(i)
				continue
			}
			u = 0
			v = result.length - 1
			while (u < v) {
				// Fast integer average without overflow.
				// eslint-disable-next-line no-bitwise
				var c = (u >>> 1) + (v >>> 1) + (u & v & 1)
				if (a[result[c]] < a[i]) {
					u = c + 1
				}
				else {
					v = c
				}
			}
			if (a[i] < a[result[u]]) {
				if (u > 0) lisTemp[i] = result[u - 1]
				result[u] = i
			}
		}
		u = result.length
		v = result[u - 1]
		while (u-- > 0) {
			result[u] = v
			v = lisTemp[v]
		}
		lisTemp.length = 0
		return result
	}

	function getNextSibling(vnodes, i, nextSibling) {
		for (; i < vnodes.length; i++) {
			if (vnodes[i] != null && vnodes[i].dom != null) return vnodes[i].dom
		}
		return nextSibling
	}

	// This covers a really specific edge case:
	// - Parent node is keyed and contains child
	// - Child is removed, returns unresolved promise in `onbeforeremove`
	// - Parent node is moved in keyed diff
	// - Remaining children still need moved appropriately
	//
	// Ideally, I'd track removed nodes as well, but that introduces a lot more
	// complexity and I'm not exactly interested in doing that.
	function moveNodes(parent, vnode, nextSibling) {
		var frag = $doc.createDocumentFragment()
		moveChildToFrag(parent, frag, vnode)
		insertNode(parent, frag, nextSibling)
	}
	function moveChildToFrag(parent, frag, vnode) {
		// Dodge the recursion overhead in a few of the most common cases.
		while (vnode.dom != null && vnode.dom.parentNode === parent) {
			if (typeof vnode.tag !== "string") {
				vnode = vnode.instance
				if (vnode != null) continue
			} else if (vnode.tag === "<") {
				for (var i = 0; i < vnode.instance.length; i++) {
					frag.appendChild(vnode.instance[i])
				}
			} else if (vnode.tag !== "[") {
				// Don't recurse for text nodes *or* elements, just fragments
				frag.appendChild(vnode.dom)
			} else if (vnode.children.length === 1) {
				vnode = vnode.children[0]
				if (vnode != null) continue
			} else {
				for (var i = 0; i < vnode.children.length; i++) {
					var child = vnode.children[i]
					if (child != null) moveChildToFrag(parent, frag, child)
				}
			}
			break
		}
	}

	function insertNode(parent, dom, nextSibling) {
		if (nextSibling != null) parent.insertBefore(dom, nextSibling)
		else parent.appendChild(dom)
	}

	function maybeSetContentEditable(vnode) {
		if (vnode.attrs == null || (
			vnode.attrs.contenteditable == null && // attribute
			vnode.attrs.contentEditable == null // property
		)) return false
		var children = vnode.children
		if (children != null && children.length === 1 && children[0].tag === "<") {
			var content = children[0].children
			if (vnode.dom.innerHTML !== content) vnode.dom.innerHTML = content
		}
		else if (children != null && children.length !== 0) throw new Error("Child node of a contenteditable must be trusted.")
		return true
	}

	//remove
	function removeNodes(parent, vnodes, start, end) {
		for (var i = start; i < end; i++) {
			var vnode = vnodes[i]
			if (vnode != null) removeNode(parent, vnode)
		}
	}
	function removeNode(parent, vnode) {
		var mask = 0
		var original = vnode.state
		var stateResult, attrsResult
		if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeremove === "function") {
			var result = callHook.call(vnode.state.onbeforeremove, vnode)
			if (result != null && typeof result.then === "function") {
				mask = 1
				stateResult = result
			}
		}
		if (vnode.attrs && typeof vnode.attrs.onbeforeremove === "function") {
			var result = callHook.call(vnode.attrs.onbeforeremove, vnode)
			if (result != null && typeof result.then === "function") {
				// eslint-disable-next-line no-bitwise
				mask |= 2
				attrsResult = result
			}
		}
		checkState(vnode, original)

		// If we can, try to fast-path it and avoid all the overhead of awaiting
		if (!mask) {
			onremove(vnode)
			removeChild(parent, vnode)
		} else {
			if (stateResult != null) {
				var next = function () {
					// eslint-disable-next-line no-bitwise
					if (mask & 1) { mask &= 2; if (!mask) reallyRemove() }
				}
				stateResult.then(next, next)
			}
			if (attrsResult != null) {
				var next = function () {
					// eslint-disable-next-line no-bitwise
					if (mask & 2) { mask &= 1; if (!mask) reallyRemove() }
				}
				attrsResult.then(next, next)
			}
		}

		function reallyRemove() {
			checkState(vnode, original)
			onremove(vnode)
			removeChild(parent, vnode)
		}
	}
	function removeHTML(parent, vnode) {
		for (var i = 0; i < vnode.instance.length; i++) {
			parent.removeChild(vnode.instance[i])
		}
	}
	function removeChild(parent, vnode) {
		// Dodge the recursion overhead in a few of the most common cases.
		while (vnode.dom != null && vnode.dom.parentNode === parent) {
			if (typeof vnode.tag !== "string") {
				vnode = vnode.instance
				if (vnode != null) continue
			} else if (vnode.tag === "<") {
				removeHTML(parent, vnode)
			} else {
				if (vnode.tag !== "[") {
					parent.removeChild(vnode.dom)
					if (!Array.isArray(vnode.children)) break
				}
				if (vnode.children.length === 1) {
					vnode = vnode.children[0]
					if (vnode != null) continue
				} else {
					for (var i = 0; i < vnode.children.length; i++) {
						var child = vnode.children[i]
						if (child != null) removeChild(parent, child)
					}
				}
			}
			break
		}
	}
	function onremove(vnode) {
		if (typeof vnode.tag !== "string" && typeof vnode.state.onremove === "function") callHook.call(vnode.state.onremove, vnode)
		if (vnode.attrs && typeof vnode.attrs.onremove === "function") callHook.call(vnode.attrs.onremove, vnode)
		if (typeof vnode.tag !== "string") {
			if (vnode.instance != null) onremove(vnode.instance)
		} else {
			var children = vnode.children
			if (Array.isArray(children)) {
				for (var i = 0; i < children.length; i++) {
					var child = children[i]
					if (child != null) onremove(child)
				}
			}
		}
	}

	//attrs
	function setAttrs(vnode, attrs, ns) {
		// If you assign an input type that is not supported by IE 11 with an assignment expression, an error will occur.
		//
		// Also, the DOM does things to inputs based on the value, so it needs set first.
		// See: https://github.com/MithrilJS/mithril.js/issues/2622
		if (vnode.tag === "input" && attrs.type != null) vnode.dom.setAttribute("type", attrs.type)
		var isFileInput = attrs != null && vnode.tag === "input" && attrs.type === "file"
		for (var key in attrs) {
			setAttr(vnode, key, null, attrs[key], ns, isFileInput)
		}
	}
	function setAttr(vnode, key, old, value, ns, isFileInput) {
		if (key === "key" || key === "is" || value == null || isLifecycleMethod(key) || (old === value && !isFormAttribute(vnode, key)) && typeof value !== "object" || key === "type" && vnode.tag === "input") return
		if (key[0] === "o" && key[1] === "n") return updateEvent(vnode, key, value)
		if (key.slice(0, 6) === "xlink:") vnode.dom.setAttributeNS("http://www.w3.org/1999/xlink", key.slice(6), value)
		else if (key === "style") updateStyle(vnode.dom, old, value)
		else if (hasPropertyKey(vnode, key, ns)) {
			if (key === "value") {
				// Only do the coercion if we're actually going to check the value.
				/* eslint-disable no-implicit-coercion */
				//setting input[value] to same value by typing on focused element moves cursor to end in Chrome
				//setting input[type=file][value] to same value causes an error to be generated if it's non-empty
				if ((vnode.tag === "input" || vnode.tag === "textarea") && vnode.dom.value === "" + value && (isFileInput || vnode.dom === activeElement())) return
				//setting select[value] to same value while having select open blinks select dropdown in Chrome
				if (vnode.tag === "select" && old !== null && vnode.dom.value === "" + value) return
				//setting option[value] to same value while having select open blinks select dropdown in Chrome
				if (vnode.tag === "option" && old !== null && vnode.dom.value === "" + value) return
				//setting input[type=file][value] to different value is an error if it's non-empty
				// Not ideal, but it at least works around the most common source of uncaught exceptions for now.
				if (isFileInput && "" + value !== "") { console.error("`value` is read-only on file inputs!"); return }
				/* eslint-enable no-implicit-coercion */
			}
			vnode.dom[key] = value
		} else {
			if (typeof value === "boolean") {
				if (value) vnode.dom.setAttribute(key, "")
				else vnode.dom.removeAttribute(key)
			}
			else vnode.dom.setAttribute(key === "className" ? "class" : key, value)
		}
	}
	function removeAttr(vnode, key, old, ns) {
		if (key === "key" || key === "is" || old == null || isLifecycleMethod(key)) return
		if (key[0] === "o" && key[1] === "n") updateEvent(vnode, key, undefined)
		else if (key === "style") updateStyle(vnode.dom, old, null)
		else if (
			hasPropertyKey(vnode, key, ns)
			&& key !== "className"
			&& key !== "title" // creates "null" as title
			&& !(key === "value" && (
				vnode.tag === "option"
				|| vnode.tag === "select" && vnode.dom.selectedIndex === -1 && vnode.dom === activeElement()
			))
			&& !(vnode.tag === "input" && key === "type")
		) {
			vnode.dom[key] = null
		} else {
			var nsLastIndex = key.indexOf(":")
			if (nsLastIndex !== -1) key = key.slice(nsLastIndex + 1)
			if (old !== false) vnode.dom.removeAttribute(key === "className" ? "class" : key)
		}
	}
	function setLateSelectAttrs(vnode, attrs) {
		if ("value" in attrs) {
			if(attrs.value === null) {
				if (vnode.dom.selectedIndex !== -1) vnode.dom.value = null
			} else {
				var normalized = "" + attrs.value // eslint-disable-line no-implicit-coercion
				if (vnode.dom.value !== normalized || vnode.dom.selectedIndex === -1) {
					vnode.dom.value = normalized
				}
			}
		}
		if ("selectedIndex" in attrs) setAttr(vnode, "selectedIndex", null, attrs.selectedIndex, undefined)
	}
	function updateAttrs(vnode, old, attrs, ns) {
		if (old && old === attrs) {
			console.warn("Don't reuse attrs object, use new object for every redraw, this will throw in next major")
		}
		if (attrs != null) {
			// If you assign an input type that is not supported by IE 11 with an assignment expression, an error will occur.
			//
			// Also, the DOM does things to inputs based on the value, so it needs set first.
			// See: https://github.com/MithrilJS/mithril.js/issues/2622
			if (vnode.tag === "input" && attrs.type != null) vnode.dom.setAttribute("type", attrs.type)
			var isFileInput = vnode.tag === "input" && attrs.type === "file"
			for (var key in attrs) {
				setAttr(vnode, key, old && old[key], attrs[key], ns, isFileInput)
			}
		}
		var val
		if (old != null) {
			for (var key in old) {
				if (((val = old[key]) != null) && (attrs == null || attrs[key] == null)) {
					removeAttr(vnode, key, val, ns)
				}
			}
		}
	}
	function isFormAttribute(vnode, attr) {
		return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode.dom === activeElement() || vnode.tag === "option" && vnode.dom.parentNode === $doc.activeElement
	}
	function isLifecycleMethod(attr) {
		return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate"
	}
	function hasPropertyKey(vnode, key, ns) {
		// Filter out namespaced keys
		return ns === undefined && (
			// If it's a custom element, just keep it.
			vnode.tag.indexOf("-") > -1 || vnode.attrs != null && vnode.attrs.is ||
			// If it's a normal element, let's try to avoid a few browser bugs.
			key !== "href" && key !== "list" && key !== "form" && key !== "width" && key !== "height"// && key !== "type"
			// Defer the property check until *after* we check everything.
		) && key in vnode.dom
	}

	//style
	var uppercaseRegex = /[A-Z]/g
	function toLowerCase(capital) { return "-" + capital.toLowerCase() }
	function normalizeKey(key) {
		return key[0] === "-" && key[1] === "-" ? key :
			key === "cssFloat" ? "float" :
				key.replace(uppercaseRegex, toLowerCase)
	}
	function updateStyle(element, old, style) {
		if (old === style) {
			// Styles are equivalent, do nothing.
		} else if (style == null) {
			// New style is missing, just clear it.
			element.style.cssText = ""
		} else if (typeof style !== "object") {
			// New style is a string, let engine deal with patching.
			element.style.cssText = style
		} else if (old == null || typeof old !== "object") {
			// `old` is missing or a string, `style` is an object.
			element.style.cssText = ""
			// Add new style properties
			for (var key in style) {
				var value = style[key]
				if (value != null) element.style.setProperty(normalizeKey(key), String(value))
			}
		} else {
			// Both old & new are (different) objects.
			// Update style properties that have changed
			for (var key in style) {
				var value = style[key]
				if (value != null && (value = String(value)) !== String(old[key])) {
					element.style.setProperty(normalizeKey(key), value)
				}
			}
			// Remove style properties that no longer exist
			for (var key in old) {
				if (old[key] != null && style[key] == null) {
					element.style.removeProperty(normalizeKey(key))
				}
			}
		}
	}

	// Here's an explanation of how this works:
	// 1. The event names are always (by design) prefixed by `on`.
	// 2. The EventListener interface accepts either a function or an object
	//    with a `handleEvent` method.
	// 3. The object does not inherit from `Object.prototype`, to avoid
	//    any potential interference with that (e.g. setters).
	// 4. The event name is remapped to the handler before calling it.
	// 5. In function-based event handlers, `ev.target === this`. We replicate
	//    that below.
	// 6. In function-based event handlers, `return false` prevents the default
	//    action and stops event propagation. We replicate that below.
	function EventDict() {
		// Save this, so the current redraw is correctly tracked.
		this._ = currentRedraw
	}
	EventDict.prototype = Object.create(null)
	EventDict.prototype.handleEvent = function (ev) {
		var handler = this["on" + ev.type]
		var result
		if (typeof handler === "function") result = handler.call(ev.currentTarget, ev)
		else if (typeof handler.handleEvent === "function") handler.handleEvent(ev)
		if (this._ && ev.redraw !== false) (0, this._)()
		if (result === false) {
			ev.preventDefault()
			ev.stopPropagation()
		}
	}

	//event
	function updateEvent(vnode, key, value) {
		if (vnode.events != null) {
			vnode.events._ = currentRedraw
			if (vnode.events[key] === value) return
			if (value != null && (typeof value === "function" || typeof value === "object")) {
				if (vnode.events[key] == null) vnode.dom.addEventListener(key.slice(2), vnode.events, false)
				vnode.events[key] = value
			} else {
				if (vnode.events[key] != null) vnode.dom.removeEventListener(key.slice(2), vnode.events, false)
				vnode.events[key] = undefined
			}
		} else if (value != null && (typeof value === "function" || typeof value === "object")) {
			vnode.events = new EventDict()
			vnode.dom.addEventListener(key.slice(2), vnode.events, false)
			vnode.events[key] = value
		}
	}

	//lifecycle
	function initLifecycle(source, vnode, hooks) {
		if (typeof source.oninit === "function") callHook.call(source.oninit, vnode)
		if (typeof source.oncreate === "function") hooks.push(callHook.bind(source.oncreate, vnode))
	}
	function updateLifecycle(source, vnode, hooks) {
		if (typeof source.onupdate === "function") hooks.push(callHook.bind(source.onupdate, vnode))
	}
	function shouldNotUpdate(vnode, old) {
		do {
			if (vnode.attrs != null && typeof vnode.attrs.onbeforeupdate === "function") {
				var force = callHook.call(vnode.attrs.onbeforeupdate, vnode, old)
				if (force !== undefined && !force) break
			}
			if (typeof vnode.tag !== "string" && typeof vnode.state.onbeforeupdate === "function") {
				var force = callHook.call(vnode.state.onbeforeupdate, vnode, old)
				if (force !== undefined && !force) break
			}
			return false
		} while (false); // eslint-disable-line no-constant-condition
		vnode.dom = old.dom
		vnode.domSize = old.domSize
		vnode.instance = old.instance
		// One would think having the actual latest attributes would be ideal,
		// but it doesn't let us properly diff based on our current internal
		// representation. We have to save not only the old DOM info, but also
		// the attributes used to create it, as we diff *that*, not against the
		// DOM directly (with a few exceptions in `setAttr`). And, of course, we
		// need to save the children and text as they are conceptually not
		// unlike special "attributes" internally.
		vnode.attrs = old.attrs
		vnode.children = old.children
		vnode.text = old.text
		return true
	}

	var currentDOM

	return function(dom, vnodes, redraw) {
		if (!dom) throw new TypeError("DOM element being rendered to does not exist.")
		if (currentDOM != null && dom.contains(currentDOM)) {
			throw new TypeError("Node is currently being rendered to and thus is locked.")
		}
		var prevRedraw = currentRedraw
		var prevDOM = currentDOM
		var hooks = []
		var active = activeElement()
		var namespace = dom.namespaceURI

		currentDOM = dom
		currentRedraw = typeof redraw === "function" ? redraw : undefined
		try {
			// First time rendering into a node clears it out
			if (dom.vnodes == null) dom.textContent = ""
			vnodes = Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes])
			updateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)
			dom.vnodes = vnodes
			// `document.activeElement` can return null: https://html.spec.whatwg.org/multipage/interaction.html#dom-document-activeelement
			if (active != null && activeElement() !== active && typeof active.focus === "function") active.focus()
			for (var i = 0; i < hooks.length; i++) hooks[i]()
		} finally {
			currentRedraw = prevRedraw
			currentDOM = prevDOM
		}
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/api/mount-redraw.js
"use strict"

var Vnode = require(4)

module.exports = function(render, schedule, console) {
	var subscriptions = []
	var pending = false
	var offset = -1

	function sync() {
		for (offset = 0; offset < subscriptions.length; offset += 2) {
			try { render(subscriptions[offset], Vnode(subscriptions[offset + 1]), redraw) }
			catch (e) { console.error(e) }
		}
		offset = -1
	}

	function redraw() {
		if (!pending) {
			pending = true
			schedule(function() {
				pending = false
				sync()
			})
		}
	}

	redraw.sync = sync

	function mount(root, component) {
		if (component != null && component.view == null && typeof component !== "function") {
			throw new TypeError("m.mount expects a component, not a vnode.")
		}

		var index = subscriptions.indexOf(root)
		if (index >= 0) {
			subscriptions.splice(index, 2)
			if (index <= offset) offset -= 2
			render(root, [])
		}

		if (component != null) {
			subscriptions.push(root, component)
			render(root, Vnode(component), redraw)
		}
	}

	return {mount: mount, redraw: redraw}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/request/request.js
"use strict"

var buildPathname = require(17)
var hasOwn = require(6)

module.exports = function($window, Promise, oncompletion) {
	var callbackCount = 0

	function PromiseProxy(executor) {
		return new Promise(executor)
	}

	// In case the global Promise is some userland library's where they rely on
	// `foo instanceof this.constructor`, `this.constructor.resolve(value)`, or
	// similar. Let's *not* break them.
	PromiseProxy.prototype = Promise.prototype
	PromiseProxy.__proto__ = Promise // eslint-disable-line no-proto

	function makeRequest(factory) {
		return function(url, args) {
			if (typeof url !== "string") { args = url; url = url.url }
			else if (args == null) args = {}
			var promise = new Promise(function(resolve, reject) {
				factory(buildPathname(url, args.params), args, function (data) {
					if (typeof args.type === "function") {
						if (Array.isArray(data)) {
							for (var i = 0; i < data.length; i++) {
								data[i] = new args.type(data[i])
							}
						}
						else data = new args.type(data)
					}
					resolve(data)
				}, reject)
			})
			if (args.background === true) return promise
			var count = 0
			function complete() {
				if (--count === 0 && typeof oncompletion === "function") oncompletion()
			}

			return wrap(promise)

			function wrap(promise) {
				var then = promise.then
				// Set the constructor, so engines know to not await or resolve
				// this as a native promise. At the time of writing, this is
				// only necessary for V8, but their behavior is the correct
				// behavior per spec. See this spec issue for more details:
				// https://github.com/tc39/ecma262/issues/1577. Also, see the
				// corresponding comment in `request/tests/test-request.js` for
				// a bit more background on the issue at hand.
				promise.constructor = PromiseProxy
				promise.then = function() {
					count++
					var next = then.apply(promise, arguments)
					next.then(complete, function(e) {
						complete()
						if (count === 0) throw e
					})
					return wrap(next)
				}
				return promise
			}
		}
	}

	function hasHeader(args, name) {
		for (var key in args.headers) {
			if (hasOwn.call(args.headers, key) && key.toLowerCase() === name) return true
		}
		return false
	}

	return {
		request: makeRequest(function(url, args, resolve, reject) {
			var method = args.method != null ? args.method.toUpperCase() : "GET"
			var body = args.body
			var assumeJSON = (args.serialize == null || args.serialize === JSON.serialize) && !(body instanceof $window.FormData || body instanceof $window.URLSearchParams)
			var responseType = args.responseType || (typeof args.extract === "function" ? "" : "json")

			var xhr = new $window.XMLHttpRequest(), aborted = false, isTimeout = false
			var original = xhr, replacedAbort
			var abort = xhr.abort

			xhr.abort = function() {
				aborted = true
				abort.call(this)
			}

			xhr.open(method, url, args.async !== false, typeof args.user === "string" ? args.user : undefined, typeof args.password === "string" ? args.password : undefined)

			if (assumeJSON && body != null && !hasHeader(args, "content-type")) {
				xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8")
			}
			if (typeof args.deserialize !== "function" && !hasHeader(args, "accept")) {
				xhr.setRequestHeader("Accept", "application/json, text/*")
			}
			if (args.withCredentials) xhr.withCredentials = args.withCredentials
			if (args.timeout) xhr.timeout = args.timeout
			xhr.responseType = responseType

			for (var key in args.headers) {
				if (hasOwn.call(args.headers, key)) {
					xhr.setRequestHeader(key, args.headers[key])
				}
			}

			xhr.onreadystatechange = function(ev) {
				// Don't throw errors on xhr.abort().
				if (aborted) return

				if (ev.target.readyState === 4) {
					try {
						var success = (ev.target.status >= 200 && ev.target.status < 300) || ev.target.status === 304 || (/^file:\/\//i).test(url)
						// When the response type isn't "" or "text",
						// `xhr.responseText` is the wrong thing to use.
						// Browsers do the right thing and throw here, and we
						// should honor that and do the right thing by
						// preferring `xhr.response` where possible/practical.
						var response = ev.target.response, message

						if (responseType === "json") {
							// For IE and Edge, which don't implement
							// `responseType: "json"`.
							if (!ev.target.responseType && typeof args.extract !== "function") {
								// Handle no-content which will not parse.
								try { response = JSON.parse(ev.target.responseText) }
								catch (e) { response = null }
							}
						} else if (!responseType || responseType === "text") {
							// Only use this default if it's text. If a parsed
							// document is needed on old IE and friends (all
							// unsupported), the user should use a custom
							// `config` instead. They're already using this at
							// their own risk.
							if (response == null) response = ev.target.responseText
						}

						if (typeof args.extract === "function") {
							response = args.extract(ev.target, args)
							success = true
						} else if (typeof args.deserialize === "function") {
							response = args.deserialize(response)
						}
						if (success) resolve(response)
						else {
							var completeErrorResponse = function() {
								try { message = ev.target.responseText }
								catch (e) { message = response }
								var error = new Error(message)
								error.code = ev.target.status
								error.response = response
								reject(error)
							}

							if (xhr.status === 0) {
								// Use setTimeout to push this code block onto the event queue
								// This allows `xhr.ontimeout` to run in the case that there is a timeout
								// Without this setTimeout, `xhr.ontimeout` doesn't have a chance to reject
								// as `xhr.onreadystatechange` will run before it
								setTimeout(function() {
									if (isTimeout) return
									completeErrorResponse()
								})
							} else completeErrorResponse()
						}
					}
					catch (e) {
						reject(e)
					}
				}
			}

			xhr.ontimeout = function (ev) {
				isTimeout = true
				var error = new Error("Request timed out")
				error.code = ev.target.status
				reject(error)
			}

			if (typeof args.config === "function") {
				xhr = args.config(xhr, args, url) || xhr

				// Propagate the `abort` to any replacement XHR as well.
				if (xhr !== original) {
					replacedAbort = xhr.abort
					xhr.abort = function() {
						aborted = true
						replacedAbort.call(this)
					}
				}
			}

			if (body == null) xhr.send()
			else if (typeof args.serialize === "function") xhr.send(args.serialize(body))
			else if (body instanceof $window.FormData || body instanceof $window.URLSearchParams) xhr.send(body)
			else xhr.send(JSON.stringify(body))
		}),
		jsonp: makeRequest(function(url, args, resolve, reject) {
			var callbackName = args.callbackName || "_mithril_" + Math.round(Math.random() * 1e16) + "_" + callbackCount++
			var script = $window.document.createElement("script")
			$window[callbackName] = function(data) {
				delete $window[callbackName]
				script.parentNode.removeChild(script)
				resolve(data)
			}
			script.onerror = function() {
				delete $window[callbackName]
				script.parentNode.removeChild(script)
				reject(new Error("JSONP request failed"))
			}
			script.src = url + (url.indexOf("?") < 0 ? "?" : "&") +
				encodeURIComponent(args.callbackKey || "callback") + "=" +
				encodeURIComponent(callbackName)
			$window.document.documentElement.appendChild(script)
		}),
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/pathname/build.js
"use strict"

var buildQueryString = require(18)
var assign = require(19)

// Returns `path` from `template` + `params`
module.exports = function(template, params) {
	if ((/:([^\/\.-]+)(\.{3})?:/).test(template)) {
		throw new SyntaxError("Template parameter names must be separated by either a '/', '-', or '.'.")
	}
	if (params == null) return template
	var queryIndex = template.indexOf("?")
	var hashIndex = template.indexOf("#")
	var queryEnd = hashIndex < 0 ? template.length : hashIndex
	var pathEnd = queryIndex < 0 ? queryEnd : queryIndex
	var path = template.slice(0, pathEnd)
	var query = {}

	assign(query, params)

	var resolved = path.replace(/:([^\/\.-]+)(\.{3})?/g, function(m, key, variadic) {
		delete query[key]
		// If no such parameter exists, don't interpolate it.
		if (params[key] == null) return m
		// Escape normal parameters, but not variadic ones.
		return variadic ? params[key] : encodeURIComponent(String(params[key]))
	})

	// In case the template substitution adds new query/hash parameters.
	var newQueryIndex = resolved.indexOf("?")
	var newHashIndex = resolved.indexOf("#")
	var newQueryEnd = newHashIndex < 0 ? resolved.length : newHashIndex
	var newPathEnd = newQueryIndex < 0 ? newQueryEnd : newQueryIndex
	var result = resolved.slice(0, newPathEnd)

	if (queryIndex >= 0) result += template.slice(queryIndex, queryEnd)
	if (newQueryIndex >= 0) result += (queryIndex < 0 ? "?" : "&") + resolved.slice(newQueryIndex, newQueryEnd)
	var querystring = buildQueryString(query)
	if (querystring) result += (queryIndex < 0 && newQueryIndex < 0 ? "?" : "&") + querystring
	if (hashIndex >= 0) result += template.slice(hashIndex)
	if (newHashIndex >= 0) result += (hashIndex < 0 ? "" : "&") + resolved.slice(newHashIndex)
	return result
}

},function (global, require, module, exports) {
// ../node_modules/mithril/querystring/build.js
"use strict"

module.exports = function(object) {
	if (Object.prototype.toString.call(object) !== "[object Object]") return ""

	var args = []
	for (var key in object) {
		destructure(key, object[key])
	}

	return args.join("&")

	function destructure(key, value) {
		if (Array.isArray(value)) {
			for (var i = 0; i < value.length; i++) {
				destructure(key + "[" + i + "]", value[i])
			}
		}
		else if (Object.prototype.toString.call(value) === "[object Object]") {
			for (var i in value) {
				destructure(key + "[" + i + "]", value[i])
			}
		}
		else args.push(encodeURIComponent(key) + (value != null && value !== "" ? "=" + encodeURIComponent(value) : ""))
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/util/assign.js
// This exists so I'm only saving it once.
"use strict"

var hasOwn = require(6)

module.exports = Object.assign || function(target, source) {
	for (var key in source) {
		if (hasOwn.call(source, key)) target[key] = source[key]
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/route.js
"use strict"

var mountRedraw = require(12)

module.exports = require(21)(typeof window !== "undefined" ? window : null, mountRedraw)

},function (global, require, module, exports) {
// ../node_modules/mithril/api/router.js
"use strict"

var Vnode = require(4)
var m = require(3)
var Promise = require(10)

var buildPathname = require(17)
var parsePathname = require(22)
var compileTemplate = require(24)
var assign = require(19)
var censor = require(25)

var sentinel = {}

function decodeURIComponentSave(component) {
	try {
		return decodeURIComponent(component)
	} catch(e) {
		return component
	}
}

module.exports = function($window, mountRedraw) {
	var callAsync = $window == null
		// In case Mithril.js' loaded globally without the DOM, let's not break
		? null
		: typeof $window.setImmediate === "function" ? $window.setImmediate : $window.setTimeout
	var p = Promise.resolve()

	var scheduled = false

	// state === 0: init
	// state === 1: scheduled
	// state === 2: done
	var ready = false
	var state = 0

	var compiled, fallbackRoute

	var currentResolver = sentinel, component, attrs, currentPath, lastUpdate

	var RouterRoot = {
		onbeforeupdate: function() {
			state = state ? 2 : 1
			return !(!state || sentinel === currentResolver)
		},
		onremove: function() {
			$window.removeEventListener("popstate", fireAsync, false)
			$window.removeEventListener("hashchange", resolveRoute, false)
		},
		view: function() {
			if (!state || sentinel === currentResolver) return
			// Wrap in a fragment to preserve existing key semantics
			var vnode = [Vnode(component, attrs.key, attrs)]
			if (currentResolver) vnode = currentResolver.render(vnode[0])
			return vnode
		},
	}

	var SKIP = route.SKIP = {}

	function resolveRoute() {
		scheduled = false
		// Consider the pathname holistically. The prefix might even be invalid,
		// but that's not our problem.
		var prefix = $window.location.hash
		if (route.prefix[0] !== "#") {
			prefix = $window.location.search + prefix
			if (route.prefix[0] !== "?") {
				prefix = $window.location.pathname + prefix
				if (prefix[0] !== "/") prefix = "/" + prefix
			}
		}
		// This seemingly useless `.concat()` speeds up the tests quite a bit,
		// since the representation is consistently a relatively poorly
		// optimized cons string.
		var path = prefix.concat()
			.replace(/(?:%[a-f89][a-f0-9])+/gim, decodeURIComponentSave)
			.slice(route.prefix.length)
		var data = parsePathname(path)

		assign(data.params, $window.history.state)

		function reject(e) {
			console.error(e)
			setPath(fallbackRoute, null, {replace: true})
		}

		loop(0)
		function loop(i) {
			// state === 0: init
			// state === 1: scheduled
			// state === 2: done
			for (; i < compiled.length; i++) {
				if (compiled[i].check(data)) {
					var payload = compiled[i].component
					var matchedRoute = compiled[i].route
					var localComp = payload
					var update = lastUpdate = function(comp) {
						if (update !== lastUpdate) return
						if (comp === SKIP) return loop(i + 1)
						component = comp != null && (typeof comp.view === "function" || typeof comp === "function")? comp : "div"
						attrs = data.params, currentPath = path, lastUpdate = null
						currentResolver = payload.render ? payload : null
						if (state === 2) mountRedraw.redraw()
						else {
							state = 2
							mountRedraw.redraw.sync()
						}
					}
					// There's no understating how much I *wish* I could
					// use `async`/`await` here...
					if (payload.view || typeof payload === "function") {
						payload = {}
						update(localComp)
					}
					else if (payload.onmatch) {
						p.then(function () {
							return payload.onmatch(data.params, path, matchedRoute)
						}).then(update, path === fallbackRoute ? null : reject)
					}
					else update("div")
					return
				}
			}

			if (path === fallbackRoute) {
				throw new Error("Could not resolve default route " + fallbackRoute + ".")
			}
			setPath(fallbackRoute, null, {replace: true})
		}
	}

	// Set it unconditionally so `m.route.set` and `m.route.Link` both work,
	// even if neither `pushState` nor `hashchange` are supported. It's
	// cleared if `hashchange` is used, since that makes it automatically
	// async.
	function fireAsync() {
		if (!scheduled) {
			scheduled = true
			// TODO: just do `mountRedraw.redraw()` here and elide the timer
			// dependency. Note that this will muck with tests a *lot*, so it's
			// not as easy of a change as it sounds.
			callAsync(resolveRoute)
		}
	}

	function setPath(path, data, options) {
		path = buildPathname(path, data)
		if (ready) {
			fireAsync()
			var state = options ? options.state : null
			var title = options ? options.title : null
			if (options && options.replace) $window.history.replaceState(state, title, route.prefix + path)
			else $window.history.pushState(state, title, route.prefix + path)
		}
		else {
			$window.location.href = route.prefix + path
		}
	}

	function route(root, defaultRoute, routes) {
		if (!root) throw new TypeError("DOM element being rendered to does not exist.")

		compiled = Object.keys(routes).map(function(route) {
			if (route[0] !== "/") throw new SyntaxError("Routes must start with a '/'.")
			if ((/:([^\/\.-]+)(\.{3})?:/).test(route)) {
				throw new SyntaxError("Route parameter names must be separated with either '/', '.', or '-'.")
			}
			return {
				route: route,
				component: routes[route],
				check: compileTemplate(route),
			}
		})
		fallbackRoute = defaultRoute
		if (defaultRoute != null) {
			var defaultData = parsePathname(defaultRoute)

			if (!compiled.some(function (i) { return i.check(defaultData) })) {
				throw new ReferenceError("Default route doesn't match any known routes.")
			}
		}

		if (typeof $window.history.pushState === "function") {
			$window.addEventListener("popstate", fireAsync, false)
		} else if (route.prefix[0] === "#") {
			$window.addEventListener("hashchange", resolveRoute, false)
		}

		ready = true
		mountRedraw.mount(root, RouterRoot)
		resolveRoute()
	}
	route.set = function(path, data, options) {
		if (lastUpdate != null) {
			options = options || {}
			options.replace = true
		}
		lastUpdate = null
		setPath(path, data, options)
	}
	route.get = function() {return currentPath}
	route.prefix = "#!"
	route.Link = {
		view: function(vnode) {
			// Omit the used parameters from the rendered element - they are
			// internal. Also, censor the various lifecycle methods.
			//
			// We don't strip the other parameters because for convenience we
			// let them be specified in the selector as well.
			var child = m(
				vnode.attrs.selector || "a",
				censor(vnode.attrs, ["options", "params", "selector", "onclick"]),
				vnode.children
			)
			var options, onclick, href

			// Let's provide a *right* way to disable a route link, rather than
			// letting people screw up accessibility on accident.
			//
			// The attribute is coerced so users don't get surprised over
			// `disabled: 0` resulting in a button that's somehow routable
			// despite being visibly disabled.
			if (child.attrs.disabled = Boolean(child.attrs.disabled)) {
				child.attrs.href = null
				child.attrs["aria-disabled"] = "true"
				// If you *really* do want add `onclick` on a disabled link, use
				// an `oncreate` hook to add it.
			} else {
				options = vnode.attrs.options
				onclick = vnode.attrs.onclick
				// Easier to build it now to keep it isomorphic.
				href = buildPathname(child.attrs.href, vnode.attrs.params)
				child.attrs.href = route.prefix + href
				child.attrs.onclick = function(e) {
					var result
					if (typeof onclick === "function") {
						result = onclick.call(e.currentTarget, e)
					} else if (onclick == null || typeof onclick !== "object") {
						// do nothing
					} else if (typeof onclick.handleEvent === "function") {
						onclick.handleEvent(e)
					}

					// Adapted from React Router's implementation:
					// https://github.com/ReactTraining/react-router/blob/520a0acd48ae1b066eb0b07d6d4d1790a1d02482/packages/react-router-dom/modules/Link.js
					//
					// Try to be flexible and intuitive in how we handle links.
					// Fun fact: links aren't as obvious to get right as you
					// would expect. There's a lot more valid ways to click a
					// link than this, and one might want to not simply click a
					// link, but right click or command-click it to copy the
					// link target, etc. Nope, this isn't just for blind people.
					if (
						// Skip if `onclick` prevented default
						result !== false && !e.defaultPrevented &&
						// Ignore everything but left clicks
						(e.button === 0 || e.which === 0 || e.which === 1) &&
						// Let the browser handle `target=_blank`, etc.
						(!e.currentTarget.target || e.currentTarget.target === "_self") &&
						// No modifier keys
						!e.ctrlKey && !e.metaKey && !e.shiftKey && !e.altKey
					) {
						e.preventDefault()
						e.redraw = false
						route.set(href, null, options)
					}
				}
			}
			return child
		},
	}
	route.param = function(key) {
		return attrs && key != null ? attrs[key] : attrs
	}

	return route
}

},function (global, require, module, exports) {
// ../node_modules/mithril/pathname/parse.js
"use strict"

var parseQueryString = require(23)

// Returns `{path, params}` from `url`
module.exports = function(url) {
	var queryIndex = url.indexOf("?")
	var hashIndex = url.indexOf("#")
	var queryEnd = hashIndex < 0 ? url.length : hashIndex
	var pathEnd = queryIndex < 0 ? queryEnd : queryIndex
	var path = url.slice(0, pathEnd).replace(/\/{2,}/g, "/")

	if (!path) path = "/"
	else {
		if (path[0] !== "/") path = "/" + path
		if (path.length > 1 && path[path.length - 1] === "/") path = path.slice(0, -1)
	}
	return {
		path: path,
		params: queryIndex < 0
			? {}
			: parseQueryString(url.slice(queryIndex + 1, queryEnd)),
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/querystring/parse.js
"use strict"

function decodeURIComponentSave(str) {
	try {
		return decodeURIComponent(str)
	} catch(err) {
		return str
	}
}

module.exports = function(string) {
	if (string === "" || string == null) return {}
	if (string.charAt(0) === "?") string = string.slice(1)

	var entries = string.split("&"), counters = {}, data = {}
	for (var i = 0; i < entries.length; i++) {
		var entry = entries[i].split("=")
		var key = decodeURIComponentSave(entry[0])
		var value = entry.length === 2 ? decodeURIComponentSave(entry[1]) : ""

		if (value === "true") value = true
		else if (value === "false") value = false

		var levels = key.split(/\]\[?|\[/)
		var cursor = data
		if (key.indexOf("[") > -1) levels.pop()
		for (var j = 0; j < levels.length; j++) {
			var level = levels[j], nextLevel = levels[j + 1]
			var isNumber = nextLevel == "" || !isNaN(parseInt(nextLevel, 10))
			if (level === "") {
				var key = levels.slice(0, j).join()
				if (counters[key] == null) {
					counters[key] = Array.isArray(cursor) ? cursor.length : 0
				}
				level = counters[key]++
			}
			// Disallow direct prototype pollution
			else if (level === "__proto__") break
			if (j === levels.length - 1) cursor[level] = value
			else {
				// Read own properties exclusively to disallow indirect
				// prototype pollution
				var desc = Object.getOwnPropertyDescriptor(cursor, level)
				if (desc != null) desc = desc.value
				if (desc == null) cursor[level] = desc = isNumber ? [] : {}
				cursor = desc
			}
		}
	}
	return data
}

},function (global, require, module, exports) {
// ../node_modules/mithril/pathname/compileTemplate.js
"use strict"

var parsePathname = require(22)

// Compiles a template into a function that takes a resolved path (without query
// strings) and returns an object containing the template parameters with their
// parsed values. This expects the input of the compiled template to be the
// output of `parsePathname`. Note that it does *not* remove query parameters
// specified in the template.
module.exports = function(template) {
	var templateData = parsePathname(template)
	var templateKeys = Object.keys(templateData.params)
	var keys = []
	var regexp = new RegExp("^" + templateData.path.replace(
		// I escape literal text so people can use things like `:file.:ext` or
		// `:lang-:locale` in routes. This is all merged into one pass so I
		// don't also accidentally escape `-` and make it harder to detect it to
		// ban it from template parameters.
		/:([^\/.-]+)(\.{3}|\.(?!\.)|-)?|[\\^$*+.()|\[\]{}]/g,
		function(m, key, extra) {
			if (key == null) return "\\" + m
			keys.push({k: key, r: extra === "..."})
			if (extra === "...") return "(.*)"
			if (extra === ".") return "([^/]+)\\."
			return "([^/]+)" + (extra || "")
		}
	) + "$")
	return function(data) {
		// First, check the params. Usually, there isn't any, and it's just
		// checking a static set.
		for (var i = 0; i < templateKeys.length; i++) {
			if (templateData.params[templateKeys[i]] !== data.params[templateKeys[i]]) return false
		}
		// If no interpolations exist, let's skip all the ceremony
		if (!keys.length) return regexp.test(data.path)
		var values = regexp.exec(data.path)
		if (values == null) return false
		for (var i = 0; i < keys.length; i++) {
			data.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1])
		}
		return true
	}
}

},function (global, require, module, exports) {
// ../node_modules/mithril/util/censor.js
"use strict"

// Note: this is mildly perf-sensitive.
//
// It does *not* use `delete` - dynamic `delete`s usually cause objects to bail
// out into dictionary mode and just generally cause a bunch of optimization
// issues within engines.
//
// Ideally, I would've preferred to do this, if it weren't for the optimization
// issues:
//
// ```js
// const hasOwn = require("./hasOwn")
// const magic = [
//     "key", "oninit", "oncreate", "onbeforeupdate", "onupdate",
//     "onbeforeremove", "onremove",
// ]
// module.exports = (attrs, extras) => {
//     const result = Object.assign(Object.create(null), attrs)
//     for (const key of magic) delete result[key]
//     if (extras != null) for (const key of extras) delete result[key]
//     return result
// }
// ```

var hasOwn = require(6)
// Words in RegExp literals are sometimes mangled incorrectly by the internal bundler, so use RegExp().
var magic = new RegExp("^(?:key|oninit|oncreate|onbeforeupdate|onupdate|onbeforeremove|onremove)$")

module.exports = function(attrs, extras) {
	var result = {}

	if (extras != null) {
		for (var key in attrs) {
			if (hasOwn.call(attrs, key) && !magic.test(key) && extras.indexOf(key) < 0) {
				result[key] = attrs[key]
			}
		}
	} else {
		for (var key in attrs) {
			if (hasOwn.call(attrs, key) && !magic.test(key)) {
				result[key] = attrs[key]
			}
		}
	}

	return result
}

},function (global, require, module, exports) {
// authentication.js
const storageName = 'nfp_sites_logintoken'

const Authentication = {
  currentUser: null,
  isAdmin: false,
  loadingListeners: [],
  authListeners: [],

  updateToken: function(token) {
    if (!token) return Authentication.clearToken()
    localStorage.setItem(storageName, token)
    Authentication.currentUser = JSON.parse(atob(token.split('.')[1]))

    if (Authentication.authListeners.length) {
      Authentication.authListeners.forEach(function(x) { x(Authentication.currentUser) })
    }
  },

  clearToken: function() {
    Authentication.currentUser = null
    localStorage.removeItem(storageName)
    Authentication.isAdmin = false
  },

  addEvent: function(event) {
    Authentication.authListeners.push(event)
  },

  setAdmin: function(item) {
    Authentication.isAdmin = item
  },

  getToken: function() {
    return localStorage.getItem(storageName)
  },
}

Authentication.updateToken(localStorage.getItem(storageName))

window.Authentication = Authentication

module.exports = Authentication

},function (global, require, module, exports) {
// admin_loader.js
const Authentication = require(26)

window.adminRoutes = {}

let loadingAdmin = false
let loadedAdmin = false
let loaded = 0
let elements = []

const onLoaded = function() {
  loaded++
  if (loaded < 2) return

  Authentication.setAdmin(Authentication.currentUser && Authentication.currentUser.rank >= 10)
  loadedAdmin = true
  m.route.set(m.route.get())
}

const onError = function(a, b, c) {
  Authentication.clearToken()
  elements.forEach(function(x) { x.remove() })
  loadedAdmin = loadingAdmin = false
  loaded = 0
  m.route.set('/')
}

const loadAdmin = function(user) {
  if (loadingAdmin) {
    if (loadedAdmin) {
      Authentication.setAdmin(user && user.rank >= 10)
    }
    return
  }
  if (!user || user.rank < 10) return

  loadingAdmin = true

  let token = Authentication.getToken()
  let element = document.createElement('link')
  elements.push(element)
  element.setAttribute('rel', 'stylesheet')
  element.setAttribute('type', 'text/css')
  element.setAttribute('href', '/assets/admin.css?token=' + token)
  element.onload = onLoaded
  element.onerror = onError
  document.getElementsByTagName('head')[0].appendChild(element)

  element = document.createElement('script')
  elements.push(element)
  element.setAttribute('type', 'text/javascript')
  element.setAttribute('src', '/assets/admin.js?token=' + token)
  element.onload = onLoaded
  element.onerror = onError
  document.body.appendChild(element)
  
  element = document.createElement('script')
  elements.push(element)
  element.setAttribute('type', 'text/javascript')
  element.setAttribute('src', '/assets/editor.js')
  element.onload = onLoaded
  element.onerror = onError
  document.body.appendChild(element)
}

Authentication.addEvent(loadAdmin)
if (Authentication.currentUser) {
  loadAdmin(Authentication.currentUser)
}

const Loader = {
  view: function() {
    return m('div.wrapper', m('div.loading-spinner'))
  },
}
const AdminResolver = {
  onmatch: function(args, requestedPath) {
    if (window.adminRoutes[args.path]) {
      return window.adminRoutes[args.path][args.id && 1 || 0]
    }
    return Loader
  },
  render: function(vnode) { return vnode },
}

module.exports = AdminResolver

},function (global, require, module, exports) {
// header.js
const m = require(1)
const Authentication = require(26)
const PageTree = require(29)

const DarkModeStorageName = 'nfp_sites_darkmode'

const Menu = {
  oninit: function(vnode) {
    this.currentActive = 'home'
    this.error = ''
    this.loading = false
    this.onbeforeupdate()

    if (!PageTree.Tree.length) {
      this.refreshTree()
    }

    
  },

  onbeforeupdate: function() {
    this.darkIsOn = localStorage.getItem(DarkModeStorageName)

    let currentPath = m.route.get()

    if (currentPath === '/') this.currentActive = 'home'
    else if (currentPath === '/login') this.currentActive = 'login'
    else if (currentPath && currentPath.startsWith('/page')) this.currentActive = currentPath.slice(currentPath.lastIndexOf('/') + 1)
  },

  refreshTree: function(vnode) {
    this.loading = true
    this.error = ''

    PageTree.refreshTree()
    .catch((err) => {
      this.error = 'Error while getting menu tree: ' + err.message + '. Click here to try again.'
    })
    .then(() => {
      this.loading = false
      m.redraw()
    })
  },

  logOut: function() {
    Authentication.clearToken()
    m.route.set('/')
  },

  toggleDarkMode: function() {
    this.darkIsOn = !this.darkIsOn
    if (this.darkIsOn) {
      localStorage.setItem(DarkModeStorageName, true)
    } else {
      localStorage.removeItem(DarkModeStorageName)
    }
    document.body.className = (this.darkIsOn ? 'nightmode ' : 'daymode ')
      + (window.supportsavif ? 'avifsupport' : 'jpegonly')
  },

  view: function() {
    return [
      m('header', [
        m('div.inside', [
          m(m.route.Link,
            { href: '/', class: 'title' },
            [
              m('div.logo.spritesheet'),
              m('h1', 'NFP Moe'),
            ]
          ),
          m('aside', [
            Authentication.currentUser
              ? [
                  m('p', [
                    'Welcome ' + Authentication.currentUser.name + '. ',
                    m('button', { onclick: this.logOut }, '(Log out)'),
                  ]),
                  m('div', [
                    m(m.route.Link, { href: '/admin/articles/add' }, 'Create article'),
                    m(m.route.Link, { href: '/admin/articles' }, 'Articles'),
                    m(m.route.Link, { href: '/admin/pages' }, 'Pages'),
                    // m(m.route.Link, { hidden: Authentication.currentUser.rank < 100, href: '/admin/staff' }, 'Staff'),
                  ])
                ]
              : null,
            m('button',
              { onclick: this.toggleDarkMode.bind(this) },
              this.darkIsOn ? 'Day mode' : 'Night mode'
            ),
          ])
        ]),
      ]),
      m('nav', [
        m('div.inside', [
          m(m.route.Link, {
            href: '/',
            class: this.currentActive === 'home' ? 'active' : '',
          }, 'Home'),
          this.loading ? m('div.loading-spinner') : null,
          PageTree.Tree.map((page) => {
            let className = ''
            if (this.currentActive === page.path) {
              className += 'active '
            }
            return m(m.route.Link, {
              href: '/page/' + page.path,
              class: className,
            }, page.name)
          }),
        ])
      ]),
      this.error ? m('div.error', { onclick: this.refreshTree.bind(this) }, this.error) : null,
    ]
  },
}

module.exports = Menu

},function (global, require, module, exports) {
// page_tree.js
const api = require(30)

const Tree = window.__nfptree && window.__nfptree.tree || []
const TreeMap = new Map()

exports.Tree = Tree
exports.TreeMap = TreeMap

function parseLeaf(tree) {
  for (let branch of tree) {
    TreeMap.set(branch.path, branch)

    if (branch.children && branch.children.length) {
      parseLeaf(branch.children)
    }
  }
}

parseLeaf(Tree)

function processPageBranch(arr, branches, prefix) {
  branches.forEach((page) => {
    arr.push({ id: page.id, name: prefix + page.name })
    if (page.children && page.children.length) {
      processPageBranch(arr, page.children, page.name + ' -> ')
    }
  })
}

exports.getFlatTree = function() {
  let arr = []
  processPageBranch(arr, Tree, '')
  return arr
}

exports.refreshTree = function() {
  return api.sendRequest({
    method: 'GET',
    url: '/api/pagetree',
  })
  .then(pages => {
    Tree.splice(0, Tree.length)
    Tree.push.apply(Tree, pages.tree)
    TreeMap.clear()
    parseLeaf(Tree)
  })
}
},function (global, require, module, exports) {
// api.js
const Authentication = require(26)

exports.sendRequest = function(options, isPagination) {
  let token = Authentication.getToken()
  let pagination = isPagination

  if (token) {
    options.headers = options.headers || {}
    options.headers['Authorization'] = 'Bearer ' + token
  }

  options.extract = function(xhr) {
    if (xhr.responseText && xhr.responseText.slice(0, 9) === '<!doctype') {
      throw new Error('Expected JSON but got HTML (' + xhr.status + ': ' + this.url.split('?')[0] + ')')
    }
    let out = null
    if (pagination && xhr.status < 300) {
      let headers = {}

      xhr.getAllResponseHeaders().split('\r\n').forEach(function(item) {
        var splitted = item.split(': ')
        headers[splitted[0]] = splitted[1]
      })

      out = {
        headers: headers || {},
        data: JSON.parse(xhr.responseText),
      }
    } else {
      if (xhr.responseText) {
        out = JSON.parse(xhr.responseText)
      } else {
        out = {}
      }
    }
    if (xhr.status >= 300) {
      throw out
    }
    return out
  }

  return m.request(options)
    .catch(function (error) {
      if (error.status === 403) {
        Authentication.clearToken()
        m.route.set('/login', { redirect: m.route.get() })
      }
      if (error.response && error.response.status) {
        return Promise.reject(error.response)
      }
      return Promise.reject(error)
    })
}

},function (global, require, module, exports) {
// footer.js
const m = require(1)
const PageTree = require(29)
const Authentication = require(26)

const Footer = {
  oninit: function(vnode) {
    this.year = new Date().getFullYear()
  },

  view: function() {
    return [
      m('div.first'),
      m('div.middle', [
        m('span', 'Sitemap'),
        m(m.route.Link, { class: 'root', href: '/' }, 'Home'),
        PageTree.Tree.map(function(page) {
          return [
            m(m.route.Link, { class: 'root', href: '/page/' + page.path }, page.name),
            (page.children
              ? m('ul', page.children.map(function(subpage) {
                  return m('li', m(m.route.Link, { class: 'child', href: '/page/' + subpage.path }, subpage.name))
                }))
              : null),
          ]
        }),
        
        !Authentication.currentUser
          ? m(m.route.Link, { class: 'root', href: '/login' }, 'Login')
          : null,
        m('div.meta', [
          '©'
          + this.year
          + ' NFP Encodes - nfp@nfp.moe - ',
          m('a', { rel: 'noopener', href: 'https://www.iubenda.com/privacy-policy/31076050', target: '_blank' }, 'Privacy Policy'),
          ' (Fuck EU)',
        ]),
      ]),
      m('div.asuna.spritesheet'),
    ]
  },
}

module.exports = Footer

},function (global, require, module, exports) {
// site_login.js
const m = require(1)
const Authentication = require(26)
const api = require(30)

const Login = {
  oninit: function(vnode) {
    this.redirect = vnode.attrs.redirect || ''
    if (Authentication.currentUser) return m.route.set('/')

    this.error = ''
    this.loading = false
    this.username = ''
    this.password = ''
  },

  oncreate: function() {
    if (Authentication.currentUser) return
  },

  loginuser: function(vnode, e) {
    e.preventDefault()
    if (!this.username) {
      this.error = 'Email is missing'
    } else if (!this.password) {
      this.error = 'Password is missing'
    } else {
      this.error = ''
    }
    if (this.error) return

    this.loading = true

    api.sendRequest({
      method: 'POST',
      url: '/api/authentication/login',
      body: {
        email: this.username,
        password: this.password,
      },
    })
    .then((result) => {
      if (!result.token) {
        return Promise.reject(new Error('Server authentication down.'))
      }
      Authentication.updateToken(result.token)
      m.route.set(this.redirect || '/')
    })
    .catch((error) => {
      this.error = 'Error while logging into NFP! ' + error.message
      vnode.state.password = ''
    })
    .then(() => {
      this.loading = false
      m.redraw()
    })
  },

  view: function(vnode) {
    return [
      m('div.wrapper', [
        this.loading ? m('div.loading-spinner') : null,
        m('div.login--first'),
        m('form.inside.login', {
          hidden: this.loading,
          onsubmit: this.loginuser.bind(this, vnode),
        }, [
          m('div.title', 'NFP.moe login'),
          this.error ? m('div.error', this.error) : null,
          m('label', 'Email or name'),
          m('input', {
            type: 'text',
            value: this.username,
            oninput: (e) => { this.username = e.currentTarget.value },
          }),
          m('label', 'Password'),
          m('input', {
            type: 'password',
            value: this.password,
            oninput: (e) => { this.password = e.currentTarget.value },
          }),
          m('input', {
            type: 'submit',
            value: 'Log in',
          }),
        ]),
        m('div.login--asuna.spritesheet'),
      ]),
    ]
  },
}

module.exports = Login

},function (global, require, module, exports) {
// site_page.js
const m = require(1)
const api = require(30)
const PageTree = require(29)
const Paginator = require(34)
// const Authentication = require('./authentication')
const Article = require(35)
const Articleslim = require(39)
const media = require(38)
const EditorBlock = require(37)
const NotFoundView = require(40)

const ArticlesPerPage = 10

const SitePage = {
  oninit: function(vnode) {
    this.error = ''
    this.loading = false
    this.treePage = null
    this.data = {
      page: null,
      articles: [],
      total_articles: 0,
      featured: null,
    }
    this.picture = null
    this.children = []
    this.currentPage = Number(m.route.param('page')) || 1

    if (window.__nfpdata) {
      this.path = m.route.param('id')
      this.lastpage = this.currentPage

      this.data = window.__nfpdata
      window.__nfpdata = null

      this.children = PageTree.Tree
      if (this.path) {
        this.children = PageTree.TreeMap.get(this.path)
        this.children = this.children && this.children.children || []
      }
      this.afterData()
    } else {
      this.fetchPage(vnode)
    }
  },

  onbeforeupdate: function(vnode) {
    this.currentPage = Number(m.route.param('page')) || 1

    if (this.path !== m.route.param('id') || this.currentPage !== this.lastpage) {
      this.fetchPage(vnode)
    }
  },

  fetchPage: function(vnode) {
    this.error = ''
    this.lastpage = this.currentPage
    this.path = m.route.param('id')

    this.loading = true

    if (this.path) {
      this.treePage = PageTree.TreeMap.get(this.path)
      this.children = this.treePage && this.treePage.children || []
    } else {
      this.treePage = { has_banner: true, has_media: true }
      this.children = PageTree.Tree
    }

    api.sendRequest({
      method: 'GET',
      url: '/api/' + (this.path ? 'pages/' + this.path : 'frontpage') + '?page=' + (this.lastpage || 1),
    })
    .then((result) => {
      this.data = result
      this.afterData()
    }, (err) => {
      this.error = err.message
    })
    .then(() => {
      this.loading = false
      m.redraw()
    })
  },

  afterData: function() {
    if (!this.data.page && this.path) {
      this.error = 'Page not found'
      return
    }

    let title = 'Page not found - NFP Moe - Anime/Manga translation group'
    if (this.data.page) {
      title = this.data.page.name + ' - NFP Moe'
    } else if (!this.path) {
      title = 'NFP Moe - Anime/Manga translation group'
    }

    this.picture = media.generatePictureSource(this.data.page,
      '(max-width: 1280px) calc(100vw - 2rem), '
      + '1248px')

    if (this.lastpage !== 1) {
      document.title = 'Page ' + this.lastpage + ' - ' + title
    } else {
      document.title = title
    }
  },

  view: function(vnode) {
    let page = this.data.page
    let featuredBanner = media.getBannerImage(this.data.featured, '/article/')
    let pageBanner = media.getBannerImage(this.data.page, '/page/')

    return ([
      this.loading
        ? [
            this.treePage.has_banner
              ? m('div.page-banner.lb')
              : null,
            this.path
              ? m('div.inside.vertical', [
                  m('div.actions', m('div.lb-link')),
                  m('h2.title', m('div.lb-main.lb--long')),
                ])
              : null,
            m('div.inside', [
              this.children.length
                ? m('aside', [
                    m('h5', m('div.lb-main')),
                    m('div.lb-link'),
                    m('ul', [
                      m('li', m('div.lb-link')),
                      m('li', m('div.lb-link')),
                      m('li', m('div.lb-link')),
                    ]),
                    m('div.lb-link'),
                    m('ul', [
                      m('li', m('div.lb-link')),
                      m('li', m('div.lb-link')),
                      m('li', m('div.lb-link')),
                    ]),
                  ])
                : null,
              !this.path
                ? m('div.container', [
                    m('article', [
                      m('h2.title', m('div.lb-main.lb--long')),
                      m('div.row', [
                        m('div.lb-main.lb--imgmini'),
                        m('div', [
                          m('div', m.trust('&nbsp;')),
                          m('div.lb-main.lb--long'),
                          m('div.lb-main'),
                          m('div.lb-main.lb--medium'),
                          m('div.lb-main.lb--medium'),
                          m('div.lb-main'),
                        ]),
                      ]),
                    ]),
                    m('article', [
                      m('h2.title', m('div.lb-main.lb--long')),
                      m('div.row', [
                        m('div.lb-main.lb--imgmini'),
                        m('div', [
                          m('div', m.trust('&nbsp;')),
                          m('div.lb-main.lb--long'),
                          m('div.lb-main'),
                          m('div.lb-main.lb--medium'),
                          m('div.lb-main.lb--medium'),
                          m('div.lb-main'),
                        ]),
                      ]),
                    ]),
                  ])
                : null,
              this.path
                ? m('div.container', [
                    this.treePage.has_media
                      ? m('div.cover', m('picture.lb.nobg'))
                      : null,
                    m('h5', m('div.lb-main.lb--long')),
                    m('articleslim', [
                      m('a.cover.nobg.lb'),
                      m('div', [
                        m('div', m('div.lb-link.lb--long')),
                        m('div.lb-main.lb--longest.lb--slim'),
                      ]),
                    ]),
                    m('articleslim', [
                      m('a.cover.nobg.lb'),
                      m('div', [
                        m('div', m('div.lb-link.lb--long')),
                        m('div.lb-main.lb--longest.lb--slim'),
                      ]),
                    ]),
                    m('articleslim', [
                      m('a.cover.nobg.lb'),
                      m('div', [
                        m('div', m('div.lb-link.lb--long')),
                        m('div.lb-main.lb--longest.lb--slim'),
                      ]),
                    ]),
                    m('articleslim', [
                      m('a.cover.nobg.lb'),
                      m('div', [
                        m('div', m('div.lb-link.lb--long')),
                        m('div.lb-main.lb--longest.lb--slim'),
                      ]),
                    ]),
                  ])
                : null,
            ]),
          ]
        : [
          this.error === 'Page not found'
            ? NotFoundView.view()
            : null,
          this.error && this.error !== 'Page not found'
            ? m('div.wrapper', m('div.error', {
                onclick: () => {
                  this.error = ''
                  this.fetchPage(vnode)
                },
              }, 'Page error: ' + this.error + '. Click here to try again'))
            : null,
          (featuredBanner
            ? m(m.route.Link, {
                class: 'page-banner',
                href: featuredBanner.path,
                style: window.supportsavif ? { 'background-image': 'url("' + featuredBanner.preview + '")' } : null,
              }, [
                m('div.page-banner-real', {
                  style: { 'background-image': 'url("' + featuredBanner.banner + '")' },
                }, m('div.inside', m('div.page-banner-title', featuredBanner.name))),
              ]
            )
            : null),
          (!featuredBanner && pageBanner
            ? m('a.page-banner', {
                href: pageBanner.original,
                target: '_blank',
                style: window.supportsavif ? { 'background-image': 'url("' + pageBanner.preview + '")' } : null,
              },
              m('div.page-banner-real', {
                style: { 'background-image': 'url("' + pageBanner.banner + '")' },
              })
            )
            : null),
          (page
            ? m('.inside.vertical', [
                m('div.actions', [
                  '« ',
                  m(m.route.Link, {
                    href: page.parent_path
                      ? '/page/' + page.parent_path
                      : '/'
                    }, page.parent_name || 'Home'),
                  Authentication.currentUser
                    ? [
                        m('div.filler'),
                        'Actions:',
                        m(m.route.Link, { href: '/admin/pages/' + page.id }, 'Edit page'),
                      ]
                    : null,
                ]),
                m('h2.title', page.name)
              ])
            : null),
          (page || this.data.articles.length
            ? m('.inside', [
                this.children.length
                  ? m('aside', { class: page ? '' : 'frontpage' }, [
                      m('h5', page ? 'View ' + page.name + ':' : 'Categories'),
                      this.children.map((page) => {
                        return [
                          m(m.route.Link, { class: 'root', href: '/page/' + page.path }, page.name),
                          (page.children && page.children.length
                            ? m('ul', page.children.map(function(subpage) {
                                return m('li', m(m.route.Link, { class: 'child', href: '/page/' + subpage.path }, subpage.name))
                              }))
                            : null),
                        ]
                      }),
                      !page
                        ? m('div.asuna.spritesheet')
                        : null,
                    ])
                  : null,
                m('div.container', [
                  (page
                    ? media.getArticlePicture(this.picture, false, page.media_path, 'Image for page ' + page.name)
                    : null),
                  (page && page.content
                    ? m('div.content', page.content.blocks.map(block => {
                        return m(EditorBlock, { block: block })
                      }))
                    : null),
                  (page && this.data.articles.length
                    ? [
                        m('h5', 'Latest posts under ' + page.name + ':'),
                        this.data.articles.map(function(article) {
                          return m(Articleslim, { article: article })
                        }),
                      ]
                    : null),
                  (!page && this.data.articles.length
                    ? this.data.articles.map(function(article) {
                        return m(Article, { article: article })
                      })
                    : null),
                  m(Paginator, {
                    base: page ? '/page/' + page.path : '/',
                    page: this.currentPage,
                    perPage: ArticlesPerPage,
                    total: this.data.total_articles,
                  }),
                ]),
              ])
            : null),
          ],
    ])
  },
}

module.exports = SitePage

},function (global, require, module, exports) {
// paginator.js
const Paginator = {
  view: function(vnode) {
    let total = vnode.attrs.total
    let currentPage = vnode.attrs.page
    let perPage = vnode.attrs.perPage || 10
    let maxPage = total / perPage + 1

    if (total <= perPage) return null

    return m('paginator', [
      currentPage > 1
        ? [
            m(m.route.Link, {
              href: vnode.attrs.base,
            }, 'First'),
            m(m.route.Link, {
              href: vnode.attrs.base + (currentPage > 2
                ? '?page=' + (currentPage - 1)
                : ''
              ),
            }, 'Previous'),
          ]
        : [ m('div'), m('div')],
      m('div', 'Page ' + currentPage),
      currentPage < maxPage
        ? [
            m(m.route.Link, {
              href: vnode.attrs.base + '?page=' + (currentPage + 1),
            }, 'Next'),
            m(m.route.Link, {
              href: vnode.attrs.base + '?page=' + maxPage,
            }, 'Last')
          ]
        : [ m('div'), m('div')],
    ])
  },
}

module.exports = Paginator

},function (global, require, module, exports) {
// article.js
const Fileinfo = require(36)
const EditorBlock = require(37)
const media = require(38)

const Article = {
  oninit: function(vnode) {
    this.lastId = null
    this.onbeforeupdate(vnode)
  },

  onbeforeupdate: function(vnode) {
    let article = vnode.attrs.article

    if (this.lastId !== article.id) {
      this.lastId = article.id

      let pictureCover = '(max-width: 639px) calc(100vw - 10px), '
        + '(max-width: 1000px) calc(100vw - 265px), '
        + '400px'
      if (vnode.attrs.full) {
        pictureCover = '(max-width: 1280) calc(100vw - 2rem), '
          + '1248px'
      }
      
      this.pictureData = media.generatePictureSource(
        article,
        pictureCover)
    }
  },

  view: function(vnode) {
    let article = vnode.attrs.article
    let files = vnode.attrs.files || article.files || []

    return m('article', {
      class: vnode.attrs.full ? 'fullsize' : '',
    }, [
      m(m.route.Link,
        { href: '/article/' + article.path, class: 'title' },
        m('h2.title', article.name)
      ),
      m('div.row', [
        media.getArticlePicture(
          this.pictureData,
          !vnode.attrs.full,
          vnode.attrs.full ? article.media_path : '/article/' + article.path,
          'Image for news item ' + article.name,
        ),
        m('div', [
          m('div.description.content',
            article.content.blocks.map(block => {
              return m(EditorBlock, { block: block })
            }),
          ),
          files.map(function(file) {
            return m(Fileinfo, { file: file, trim: true })
          }),
          m('p.meta', [
            'Posted ',
            (article.page_path ? ['in ', m(m.route.Link, { href: '/page/' + article.page_path }, article.page_name), ' '] : ''),
            'at ' + (article.publish_at.replace('T', ' ').split('.')[0]).substr(0, 16),
            ' by ' + (article.admin_name || 'Admin'),
          ]),
        ]),
      ]),
    ])
  },
}

module.exports = Article

},function (global, require, module, exports) {
// fileinfo.js
const Fileinfo = {
  getPrefix: function(vnode) {
    if (!vnode.attrs.file.filename.endsWith('.torrent')) {
      return vnode.attrs.file.filename.split('.').slice(-1)
    }
    if (vnode.attrs.file.filename.indexOf('720 ') >= 0) {
      return '720p'
    }
    if (vnode.attrs.file.filename.indexOf('1080 ') >= 0) {
      return '1080p'
    }
    if (vnode.attrs.file.filename.indexOf('480 ') >= 0) {
      return '480p'
    }
    if (vnode.attrs.file.filename.toLowerCase().indexOf('flac') >= 0) {
      return 'FLAC'
    }
    if (vnode.attrs.file.filename.toLowerCase().indexOf('mp3') >= 0) {
      return 'MP3'
    }
    if (vnode.attrs.file.filename.toLowerCase().indexOf('psd') >= 0) {
      return 'PSD'
    }
    if (vnode.attrs.file.filename.toLowerCase().indexOf('.zip') >= 0) {
      return 'ZIP'
    }
    return 'Other'
  },

  getTitle: function(vnode) {
    if (vnode.attrs.file.meta.torrent) {
      return vnode.attrs.file.meta.torrent.name
    }
    return vnode.attrs.file.filename
  },

  getDownloadName: function(vnode) {
    if (vnode.attrs.file.meta.torrent) {
      return 'Torrent'
    }
    return 'Download'
  },

  getSize: function(orgSize) {
    var size = orgSize
    var i = -1
    var byteUnits = [' kB', ' MB', ' GB', ' TB', 'PB', 'EB', 'ZB', 'YB']
    do {
      size = size / 1024
      i++
    } while (size > 1024)

    return Math.max(size, 0.1).toFixed(1) + byteUnits[i]
  },

  view: function(vnode) {
    return m('fileinfo', { class: vnode.attrs.slim ? 'slim' : ''}, [
      m('p', [
        m('span', this.getPrefix(vnode) + ':'),
        m('a', {
          target: '_blank',
          rel: 'noopener',
          href: vnode.attrs.file.path,
        }, this.getDownloadName(vnode)),
        vnode.attrs.file.magnet
          ? m('a', {
              href: vnode.attrs.file.magnet,
            }, 'Magnet')
          : null,
        this.getTitle(vnode),
      ]),
      vnode.attrs.file.meta.torrent
          && !vnode.attrs.slim
          && vnode.attrs.file.meta.torrent.files.length > 1
          && (!vnode.attrs.trim || vnode.attrs.file.meta.torrent.files.length <= 4)
        ? m('ul', vnode.attrs.file.meta.torrent.files.map(function(file) {
            return m('li', [
              file.name + ' ',
              m('span.meta', '(' + Fileinfo.getSize(file.size) + ')'),
            ])
          }))
        : null,
      vnode.attrs.trim
          && vnode.attrs.file.meta.torrent
          && vnode.attrs.file.meta.torrent.files.length > 4
        ? m('div.trimmed', '...' + vnode.attrs.file.meta.torrent.files.length + ' files...')
        : null,
      vnode.children,
    ])
  },
}

module.exports = Fileinfo

},function (global, require, module, exports) {
// editorblock.js
/*
Blocks:
  * Paragraph
  * Header
  * SimpleImage
  * Quote
  * CodeTool
  * List
  * Delimiter
  * RawTool

Other:
 * InlineCode
*/

const EditorBlock = {
  oninit: function(vnode) {
    this.id = null
    this.output = null
    this.onbeforeupdate(vnode)
  },

  onbeforeupdate: function(vnode) {
    if (!vnode.attrs.block && !this.id) {
      return false
    }
    if (vnode.attrs.block && vnode.attrs.block.id
        && vnode.attrs.block.id === this.id) {
      return false
    }

    if (vnode.attrs.block && vnode.attrs.block.id
        && vnode.attrs.block.id !== this.id) {
      this.renderblock(vnode)
    } else {
      this.output = null
    }
  },

  renderblock: function(vnode) {
    let block = vnode.attrs.block
    this.id = block.id
    switch (block.type) {
      case 'header':
        this.output = m('h' + block.data.level, block.data.text)
        break;
      case 'paragraph':
        this.output = m('p', m.trust(block.data.text))
        break
      case 'htmlraw':
        this.output = m.trust(block.data.html)
        break
      case 'quote':
        this.output = m('blockquote', [
          m('p', block.data.text),
          m('span.author', block.data.caption),
        ])
        break
      case 'list':
        this.output = m(
          block.data.style === 'unordered' ? 'ul' : 'ol',
          block.data.items.map(item => m('li', item))
        )
        break
      case 'code':
        this.output = m('pre', block.data.code)
        break
      default:
        this.output = m('p', m.trust(block))
        break
    }
  },

  view: function(vnode) {
    return this.output
  }
}

module.exports = EditorBlock

},function (global, require, module, exports) {
// media.js
'use strict';
const m = require(1)

function generatePictureSource(item, cover) {
  if (!item || !item.media_alt_prefix) return null

  return {
    fallback:  item.media_alt_prefix + '_small.jpg',
    jpeg: item.media_alt_prefix + '_small.jpg' + ' 720w, '
        + item.media_alt_prefix + '_medium.jpg' + ' 1300w, '
        + item.media_alt_prefix + '_large.jpg  1920w',
    avif: item.media_alt_prefix + '_small.avif' + ' 720w, '
        + item.media_alt_prefix + '_medium.avif' + ' 1300w, '
        + item.media_alt_prefix + '_large.avif 1920w',
    cover: cover,
    preview: item.media_avif_preview,
  }
}
exports.generatePictureSource = generatePictureSource

function getBannerImage(item, prefix) {
  if (!item || !item.banner_alt_prefix) return null

  let out = {
    path: prefix + item.path,
    name: item.name,
    original: item.banner_path,
    banner: item.banner_alt_prefix,
    preview: item.banner_avif_preview,
  }

  var deviceWidth = window.innerWidth
  var pixelRatio = window.devicePixelRatio || 1
  if ((deviceWidth < 720 && pixelRatio <= 1)
      || (deviceWidth < 360 && pixelRatio <= 2)) {
    out.banner += '_small'
  } else if ((deviceWidth < 1300 && pixelRatio <= 1)
            || (deviceWidth < 650 && pixelRatio <= 2)) {
    out.banner += '_medium'
  } else {
    out.banner += '_large'
  }
  if (window.supportsavif) {
    out.banner += '.avif'
  } else {
    out.banner += '.jpg'
  }

  return out
}
exports.getBannerImage = getBannerImage

function getArticlePicture(pictureData, useRouteLink, path, altText, fallback) {
  if (!pictureData) return fallback || null

  return m(useRouteLink ? m.route.Link : 'a', {
    class: 'cover ' + (pictureData.preview && window.supportsavif ? 'haspreview' : ''),
    rel: useRouteLink ? null : 'noopener',
    target: useRouteLink ? null : '_blank',
    href: path,
  }, [
    pictureData.preview && window.supportsavif ? m('img', { src: pictureData.preview }) : null,
    m('picture', [
      m('source', {
        srcset: pictureData.avif,
        sizes: pictureData.cover,
        type: 'image/avif',
      }),
      m('img', {
        srcset: pictureData.jpeg,
        sizes: pictureData.cover,
        alt: altText,
        src: pictureData.fallback,
      }),
    ])
  ])
}
exports.getArticlePicture = getArticlePicture
},function (global, require, module, exports) {
// article_slim.js
const Fileinfo = require(36)
const media = require(38)

const Articleslim = {
  oninit: function(vnode) {
    this.lastId = null
    this.onbeforeupdate(vnode)
  },

  strip: function(html) {
    var doc = new DOMParser().parseFromString(html, 'text/html')
    var out = (doc.body.textContent || '').replace(/([\.!?])/g, '$1 ')
    var splitted = out.split('.')
    if (splitted.length > 2) {
      return splitted.slice(0, 2).join('.') + '...'
    }
    return out
  },

  onbeforeupdate: function(vnode) {
    let article = vnode.attrs.article

    if (this.lastId !== article.id) {
      this.lastId = article.id
      this.description = null

      if (article.content) {
        for (let i = 0; i < article.content.blocks.length; i++) {
          if (article.content.blocks[i].type === 'paragraph') {
            this.description = article.content.blocks[i].data.text
            break
          } else if (article.content.blocks[i].type === 'htmlraw') {
            this.description = this.strip(article.content.blocks[i].data.html)
            break
          }
        }
      }

      this.pictureData = media.generatePictureSource(
        article,
        '(max-width: 440px) calc(100vw - 40px), '
        + '124px')
    }
  },

  view: function(vnode) {
    let article = vnode.attrs.article

    return m('articleslim', [
      media.getArticlePicture(
        this.pictureData,
        true,
        '/article/' + article.path,
        'Image for news item ' + article.name,
        m('a.cover.nobg')
      ),
      m('div', [
        m(m.route.Link,
          { class: 'title', href: '/article/' + article.path },
          article.name
        ),
        (article.files && article.files.length
          ? article.files.map(function(file) {
              return m(Fileinfo, { file: file, slim: true })
            })
          : this.description
            ? m('p.description', this.description)
            : null),
      ]),
    ])
  },
}

module.exports = Articleslim

},function (global, require, module, exports) {
// site_404.js
const m = require(1)

const NotFoundView = {
  oninit: function(vnode) {
  },

  oncreate: function() {
  },

  view: function(vnode) {
    return [
      m('div.wrapper.not_found', [
        m('h4.notfound', '404: Page, article or file was not found'),
        m('div.asuna.spritesheet'),
      ]),
    ]
  },
}

module.exports = NotFoundView

},function (global, require, module, exports) {
// site_article.js
const m = require(1)
const Article = require(35)
const api = require(30)
const media = require(38)
const NotFoundView = require(40)

window.LoadComments = false
window.HyvorLoaded = false
window.HYVOR_TALK_WEBSITE = 7544

const SiteArticle = {
  oninit: function(vnode) {
    this.error = ''
    this.loading = false
    this.showLoading = null
    this.data = {
      article: null,
      files: [],
    }
    this.showcomments = false

    if (window.__nfpdata) {
      this.path = m.route.param('id')
      this.data = window.__nfpdata
      window.__nfpdata = null
      this.afterData()
    } else {
      this.fetchArticle(vnode)
    }
  },

  onbeforeupdate: function(vnode) {
    if (this.path !== m.route.param('id')) {
      this.fetchArticle(vnode)
    }
  },

  fetchArticle: function(vnode) {
    this.error = ''
    this.path = m.route.param('id')
    this.showcomments = false

    if (this.showLoading) {
      clearTimeout(this.showLoading)
    }

    if (this.data.article) {
      this.showLoading = setTimeout(() => {
        this.showLoading = null
        this.loading = true
        m.redraw()
      }, 150)
    } else {
      this.loading = true
    }

    api.sendRequest({
      method: 'GET',
      url: '/api/articles/' + this.path,
    })
    .then((result) => {
      this.data = result
      this.afterData()
    }, (err) => {
      this.error = err.message
    })
    .then(() => {
      clearTimeout(this.showLoading)
      this.showLoading = null
      this.loading = false
      m.redraw()
    })
  },

  afterData: function() {
    if (!this.data.article) {
      this.error = 'Article not found'
    }
  },

  view: function(vnode) {
    let article = this.data.article

    return [
      this.loading
        ? m('.inside.vertical', [
            m('div.actions', m('div.lb-link')),
            m('article.fullsize', [
              m('h2.title', m('div.lb-main.lb--long')),
              m('div.row', [
                m('div.cover', m('picture.lb.nobg')),
                m('div.description', [
                  m('div.lb-main.lb--long'),
                  m('div.lb-main'),
                  m('div.lb-main.lb--medium'),
                  m('div.lb-main.lb--medium'),
                  m('div.lb-main'),
                  m('p', m.trust('&nbsp;')),
                  m('fileinfo', [
                    m('div.lb-main.lb--slim.lb--longest'),
                    m('ul', [
                      m('li', m('div.lb-main.lb--slim.lb--longest')),
                      m('li', m('div.lb-main.lb--slim.lb--longest')),
                    ])
                  ]),
                ]),
              ]),
            ]),
          ])
        : null,
      !this.loading && this.error === 'Article not found'
        ? NotFoundView.view()
        : null,
      !this.loading && this.error && this.error !== 'Article not found'
        ? m('div.wrapper', m('div.error', {
            onclick: () => {
              this.error = ''
              this.fetchPage(vnode)
            },
          }, 'Article error: ' + this.error + '. Click here to try again'))
        : null,
      (!this.loading && article
        ? m('.inside.vertical', [
            m('div.actions', [
              '« ',
              m(m.route.Link, {
                href: article.page_path
                  ? '/page/' + article.page_path
                  : '/'
                }, article.page_name || 'Home'),
              Authentication.currentUser
                ? [
                    m('div.filler'),
                    'Actions:',
                    m(m.route.Link, { href: '/admin/articles/' + article.id }, 'Edit article'),
                  ]
                : null,
            ]),
            article ? m(Article, { full: true, files: this.data.files, article: article }) : null,
            window.LoadComments
              ? m('div#hyvor-talk-view', { oncreate: function() {
                  window.HYVOR_TALK_CONFIG = {
                    url: false,
                    id: article.path,
                    loadMode: scroll,
                  }
                  if (!window.HyvorLoaded) {
                    window.HyvorLoaded = true
                    var s = document.createElement('script')
                    s.src = 'https://talk.hyvor.com/web-api/embed.js';
                    s.type = 'text/javascript'
                    // s.setAttribute('crossorigin', '')
                    // s.setAttribute('data-timestamp', +new Date());
                    document.body.appendChild(s);
                  } else {
                    hyvor_talk.reload()
                  }
                }}, m('div.loading-spinner'))
            : m('button.comments', {
              style: 'display: none',
                onclick: function() { window.LoadComments = true },
              }, 'Open comment discussion'),
          ])
        : null),
    ]
  },
}

module.exports = SiteArticle

}]));