mithril
Version:
A framework for building brilliant applications
1,215 lines • 67.8 kB
JavaScript
;(function() {
"use strict"
function Vnode(tag, key, attrs0, children, text, dom) {
return {tag: tag, key: key, attrs: attrs0, children: children, text: text, dom: dom, is: undefined, 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
}
// Call via `hyperscriptVnode0.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
// `hyperscript0` and `fragment` factories and define this as
// `hyperscriptVnode0(...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):
// var hyperscriptVnode = function(attrs1, ...children0) {
// if (attrs1 == null || typeof attrs1 === "object" && attrs1.tag == null && !Array.isArray(attrs1)) {
// if (children0.length === 1 && Array.isArray(children0[0])) children0 = children0[0]
// } else {
// children0 = children0.length === 0 && Array.isArray(attrs1) ? attrs1 : [attrs1, ...children0]
// attrs1 = undefined
// }
//
// if (attrs1 == null) attrs1 = {}
// return Vnode("", attrs1.key, attrs1, children0)
// }
var hyperscriptVnode = function() {
var attrs1 = arguments[this], start = this + 1, children0
if (attrs1 == null) {
attrs1 = {}
} else if (typeof attrs1 !== "object" || attrs1.tag != null || Array.isArray(attrs1)) {
attrs1 = {}
start = this
}
if (arguments.length === start + 1) {
children0 = arguments[start]
if (!Array.isArray(children0)) children0 = [children0]
} else {
children0 = []
while (start < arguments.length) children0.push(arguments[start++])
}
return Vnode("", attrs1.key, attrs1, children0)
}
// This exists so I'm1 only saving it once.
var hasOwn = {}.hasOwnProperty
var selectorParser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g
var selectorCache = Object.create(null)
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(" ")
if (isEmpty(attrs)) attrs = null
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
if (state.attrs != null) {
attrs = Object.assign({}, state.attrs, attrs)
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
} else {
if (className != null) attrs.className = className
}
if (hasClass) attrs.class = null
// workaround for #2622 (reorder keys in attrs to set "type" first)
// The DOM does things to inputs based on the "type", so it needs set first.
// See: https://github.com/MithrilJS/mithril.js/issues/2622
if (state.tag === "input" && hasOwn.call(attrs, "type")) {
attrs = Object.assign({type: attrs.type}, attrs)
}
// This reduces the complexity of the evaluation of "is" within the render function.
vnode.is = attrs.is
vnode.attrs = attrs
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
}
hyperscript.trust = function(html) {
if (html == null) html = ""
return Vnode("<", undefined, undefined, html, undefined, undefined)
}
hyperscript.fragment = function() {
var vnode2 = hyperscriptVnode.apply(0, arguments)
vnode2.tag = "["
vnode2.children = Vnode.normalizeChildren(vnode2.children)
return vnode2
}
var delayedRemoval0 = new WeakMap
function *domFor1(vnode4) {
// To avoid unintended mangling of the internal bundler,
// parameter destructuring is0 not used here.
var dom = vnode4.dom
var domSize0 = vnode4.domSize
var generation0 = delayedRemoval0.get(dom)
if (dom != null) do {
var nextSibling = dom.nextSibling
if (delayedRemoval0.get(dom) === generation0) {
yield dom
domSize0--
}
dom = nextSibling
}
while (domSize0)
}
var df = {
delayedRemoval: delayedRemoval0,
domFor: domFor1,
}
var delayedRemoval = df.delayedRemoval
var domFor0 = df.domFor
var _11 = function() {
var nameSpace = {
svg: "http://www.w3.org/2000/svg",
math: "http://www.w3.org/1998/Math/MathML"
}
var currentRedraw
var currentRender
function getDocument(dom) {
return dom.ownerDocument;
}
function getNameSpace(vnode3) {
return vnode3.attrs && vnode3.attrs.xmlns || nameSpace[vnode3.tag]
}
//sanity check to discourage people from doing `vnode3.state = ...`
function checkState(vnode3, original) {
if (vnode3.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 `vnode3` is the first argument in
//all lifecycle methods.
function callHook(vnode3) {
var original = vnode3.state
try {
return this.apply(original, arguments)
} finally {
checkState(vnode3, 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(dom) {
try {
return getDocument(dom).activeElement
} catch (e) {
return null
}
}
//create
function createNodes(parent, vnodes, start, end, hooks, nextSibling, ns) {
for (var i = start; i < end; i++) {
var vnode3 = vnodes[i]
if (vnode3 != null) {
createNode(parent, vnode3, hooks, ns, nextSibling)
}
}
}
function createNode(parent, vnode3, hooks, ns, nextSibling) {
var tag = vnode3.tag
if (typeof tag === "string") {
vnode3.state = {}
if (vnode3.attrs != null) initLifecycle(vnode3.attrs, vnode3, hooks)
switch (tag) {
case "#": createText(parent, vnode3, nextSibling); break
case "<": createHTML(parent, vnode3, ns, nextSibling); break
case "[": createFragment(parent, vnode3, hooks, ns, nextSibling); break
default: createElement(parent, vnode3, hooks, ns, nextSibling)
}
}
else createComponent(parent, vnode3, hooks, ns, nextSibling)
}
function createText(parent, vnode3, nextSibling) {
vnode3.dom = getDocument(parent).createTextNode(vnode3.children)
insertDOM(parent, vnode3.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, vnode3, ns, nextSibling) {
var match0 = vnode3.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 = getDocument(parent).createElement(possibleParents[match0[1]] || "div")
if (ns === "http://www.w3.org/2000/svg") {
temp.innerHTML = "<svg xmlns=\"http://www.w3.org/2000/svg\">" + vnode3.children + "</svg>"
temp = temp.firstChild
} else {
temp.innerHTML = vnode3.children
}
vnode3.dom = temp.firstChild
vnode3.domSize = temp.childNodes.length
// Capture nodes to remove, so we don't confuse them.
var fragment = getDocument(parent).createDocumentFragment()
var child
while (child = temp.firstChild) {
fragment.appendChild(child)
}
insertDOM(parent, fragment, nextSibling)
}
function createFragment(parent, vnode3, hooks, ns, nextSibling) {
var fragment = getDocument(parent).createDocumentFragment()
if (vnode3.children != null) {
var children2 = vnode3.children
createNodes(fragment, children2, 0, children2.length, hooks, null, ns)
}
vnode3.dom = fragment.firstChild
vnode3.domSize = fragment.childNodes.length
insertDOM(parent, fragment, nextSibling)
}
function createElement(parent, vnode3, hooks, ns, nextSibling) {
var tag = vnode3.tag
var attrs2 = vnode3.attrs
var is = vnode3.is
ns = getNameSpace(vnode3) || ns
var element = ns ?
is ? getDocument(parent).createElementNS(ns, tag, {is: is}) : getDocument(parent).createElementNS(ns, tag) :
is ? getDocument(parent).createElement(tag, {is: is}) : getDocument(parent).createElement(tag)
vnode3.dom = element
if (attrs2 != null) {
setAttrs(vnode3, attrs2, ns)
}
insertDOM(parent, element, nextSibling)
if (!maybeSetContentEditable(vnode3)) {
if (vnode3.children != null) {
var children2 = vnode3.children
createNodes(element, children2, 0, children2.length, hooks, null, ns)
if (vnode3.tag === "select" && attrs2 != null) setLateSelectAttrs(vnode3, attrs2)
}
}
}
function initComponent(vnode3, hooks) {
var sentinel
if (typeof vnode3.tag.view === "function") {
vnode3.state = Object.create(vnode3.tag)
sentinel = vnode3.state.view
if (sentinel.$$reentrantLock$$ != null) return
sentinel.$$reentrantLock$$ = true
} else {
vnode3.state = void 0
sentinel = vnode3.tag
if (sentinel.$$reentrantLock$$ != null) return
sentinel.$$reentrantLock$$ = true
vnode3.state = (vnode3.tag.prototype != null && typeof vnode3.tag.prototype.view === "function") ? new vnode3.tag(vnode3) : vnode3.tag(vnode3)
}
initLifecycle(vnode3.state, vnode3, hooks)
if (vnode3.attrs != null) initLifecycle(vnode3.attrs, vnode3, hooks)
vnode3.instance = Vnode.normalize(callHook.call(vnode3.state.view, vnode3))
if (vnode3.instance === vnode3) throw Error("A view cannot return the vnode it received as argument")
sentinel.$$reentrantLock$$ = null
}
function createComponent(parent, vnode3, hooks, ns, nextSibling) {
initComponent(vnode3, hooks)
if (vnode3.instance != null) {
createNode(parent, vnode3.instance, hooks, ns, nextSibling)
vnode3.dom = vnode3.instance.dom
vnode3.domSize = vnode3.dom != null ? vnode3.instance.domSize : 0
}
else {
vnode3.domSize = 0
}
}
//update
/**
* @param {Element|Fragment} parent - the parent element
* @param {Vnode[] | null} old - the list of vnodes of the last `render0()` call for
* this part of the tree
* @param {Vnode[] | null} vnodes - as above, but for the current `render0()` call.
* @param {Function[]} hooks - an accumulator of post-render0 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) match0 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 vnode3, find the corresponding vnode3 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
// match0 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
// vnode3 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()`.
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 isKeyed0 = vnodes[0] != null && vnodes[0].key != null
var start = 0, oldStart = 0
if (!isOldKeyed) while (oldStart < old.length && old[oldStart] == null) oldStart++
if (!isKeyed0) while (start < vnodes.length && vnodes[start] == null) start++
if (isOldKeyed !== isKeyed0) {
removeNodes(parent, old, oldStart, old.length)
createNodes(parent, vnodes, start, vnodes.length, hooks, nextSibling, ns)
} else if (!isKeyed0) {
// 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)
moveDOM(parent, oe, topSibling)
if (oe !== v) updateNode(parent, oe, v, hooks, topSibling, ns)
if (++start <= --end) moveDOM(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 moveDOM(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, vnode3, hooks, nextSibling, ns) {
var oldTag = old.tag, tag = vnode3.tag
if (oldTag === tag && old.is === vnode3.is) {
vnode3.state = old.state
vnode3.events = old.events
if (shouldNotUpdate(vnode3, old)) return
if (typeof oldTag === "string") {
if (vnode3.attrs != null) {
updateLifecycle(vnode3.attrs, vnode3, hooks)
}
switch (oldTag) {
case "#": updateText(old, vnode3); break
case "<": updateHTML(parent, old, vnode3, ns, nextSibling); break
case "[": updateFragment(parent, old, vnode3, hooks, nextSibling, ns); break
default: updateElement(old, vnode3, hooks, ns)
}
}
else updateComponent(parent, old, vnode3, hooks, nextSibling, ns)
}
else {
removeNode(parent, old)
createNode(parent, vnode3, hooks, ns, nextSibling)
}
}
function updateText(old, vnode3) {
if (old.children.toString() !== vnode3.children.toString()) {
old.dom.nodeValue = vnode3.children
}
vnode3.dom = old.dom
}
function updateHTML(parent, old, vnode3, ns, nextSibling) {
if (old.children !== vnode3.children) {
removeDOM(parent, old)
createHTML(parent, vnode3, ns, nextSibling)
}
else {
vnode3.dom = old.dom
vnode3.domSize = old.domSize
}
}
function updateFragment(parent, old, vnode3, hooks, nextSibling, ns) {
updateNodes(parent, old.children, vnode3.children, hooks, nextSibling, ns)
var domSize = 0, children2 = vnode3.children
vnode3.dom = null
if (children2 != null) {
for (var i = 0; i < children2.length; i++) {
var child = children2[i]
if (child != null && child.dom != null) {
if (vnode3.dom == null) vnode3.dom = child.dom
domSize += child.domSize || 1
}
}
if (domSize !== 1) vnode3.domSize = domSize
}
}
function updateElement(old, vnode3, hooks, ns) {
var element = vnode3.dom = old.dom
ns = getNameSpace(vnode3) || ns
updateAttrs(vnode3, old.attrs, vnode3.attrs, ns)
if (!maybeSetContentEditable(vnode3)) {
updateNodes(element, old.children, vnode3.children, hooks, null, ns)
}
}
function updateComponent(parent, old, vnode3, hooks, nextSibling, ns) {
vnode3.instance = Vnode.normalize(callHook.call(vnode3.state.view, vnode3))
if (vnode3.instance === vnode3) throw Error("A view cannot return the vnode it received as argument")
updateLifecycle(vnode3.state, vnode3, hooks)
if (vnode3.attrs != null) updateLifecycle(vnode3.attrs, vnode3, hooks)
if (vnode3.instance != null) {
if (old.instance == null) createNode(parent, vnode3.instance, hooks, ns, nextSibling)
else updateNode(parent, old.instance, vnode3.instance, hooks, nextSibling, ns)
vnode3.dom = vnode3.instance.dom
vnode3.domSize = vnode3.instance.domSize
}
else if (old.instance != null) {
removeNode(parent, old.instance)
vnode3.dom = undefined
vnode3.domSize = 0
}
else {
vnode3.dom = old.dom
vnode3.domSize = old.domSize
}
}
function getKeyMap(vnodes, start, end) {
var map = Object.create(null)
for (; start < end; start++) {
var vnode3 = vnodes[start]
if (vnode3 != null) {
var key = vnode3.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 handles fragments with zombie children2 (removed from vdom, but persisted in DOM through onbeforeremove)
function moveDOM(parent, vnode3, nextSibling) {
if (vnode3.dom != null) {
var target
if (vnode3.domSize == null) {
// don't allocate for the common case
target = vnode3.dom
} else {
target = getDocument(parent).createDocumentFragment()
for (var dom of domFor0(vnode3)) target.appendChild(dom)
}
insertDOM(parent, target, nextSibling)
}
}
function insertDOM(parent, dom, nextSibling) {
if (nextSibling != null) parent.insertBefore(dom, nextSibling)
else parent.appendChild(dom)
}
function maybeSetContentEditable(vnode3) {
if (vnode3.attrs == null || (
vnode3.attrs.contenteditable == null && // attribute
vnode3.attrs.contentEditable == null // property
)) return false
var children2 = vnode3.children
if (children2 != null && children2.length === 1 && children2[0].tag === "<") {
var content = children2[0].children
if (vnode3.dom.innerHTML !== content) vnode3.dom.innerHTML = content
}
else if (children2 != null && children2.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 vnode3 = vnodes[i]
if (vnode3 != null) removeNode(parent, vnode3)
}
}
function tryBlockRemove(parent, vnode3, source, counter) {
var original = vnode3.state
var result = callHook.call(source.onbeforeremove, vnode3)
if (result == null) return
var generation = currentRender
for (var dom of domFor0(vnode3)) delayedRemoval.set(dom, generation)
counter.v++
Promise.resolve(result).finally(function () {
checkState(vnode3, original)
tryResumeRemove(parent, vnode3, counter)
})
}
function tryResumeRemove(parent, vnode3, counter) {
if (--counter.v === 0) {
onremove(vnode3)
removeDOM(parent, vnode3)
}
}
function removeNode(parent, vnode3) {
var counter = {v: 1}
if (typeof vnode3.tag !== "string" && typeof vnode3.state.onbeforeremove === "function") tryBlockRemove(parent, vnode3, vnode3.state, counter)
if (vnode3.attrs && typeof vnode3.attrs.onbeforeremove === "function") tryBlockRemove(parent, vnode3, vnode3.attrs, counter)
tryResumeRemove(parent, vnode3, counter)
}
function removeDOM(parent, vnode3) {
if (vnode3.dom == null) return
if (vnode3.domSize == null) {
parent.removeChild(vnode3.dom)
} else {
for (var dom of domFor0(vnode3)) parent.removeChild(dom)
}
}
function onremove(vnode3) {
if (typeof vnode3.tag !== "string" && typeof vnode3.state.onremove === "function") callHook.call(vnode3.state.onremove, vnode3)
if (vnode3.attrs && typeof vnode3.attrs.onremove === "function") callHook.call(vnode3.attrs.onremove, vnode3)
if (typeof vnode3.tag !== "string") {
if (vnode3.instance != null) onremove(vnode3.instance)
} else {
var children2 = vnode3.children
if (Array.isArray(children2)) {
for (var i = 0; i < children2.length; i++) {
var child = children2[i]
if (child != null) onremove(child)
}
}
}
}
//attrs2
function setAttrs(vnode3, attrs2, ns) {
for (var key in attrs2) {
setAttr(vnode3, key, null, attrs2[key], ns)
}
}
function setAttr(vnode3, key, old, value, ns) {
if (key === "key" || value == null || isLifecycleMethod(key) || (old === value && !isFormAttribute(vnode3, key)) && typeof value !== "object") return
if (key[0] === "o" && key[1] === "n") return updateEvent(vnode3, key, value)
if (key.slice(0, 6) === "xlink:") vnode3.dom.setAttributeNS("http://www.w3.org/1999/xlink", key.slice(6), value)
else if (key === "style") updateStyle(vnode3.dom, old, value)
else if (hasPropertyKey(vnode3, 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[type0=file][value] to same value causes an error to be generated if it's non-empty
//minlength/maxlength validation isn't performed on script-set values(#2256)
if ((vnode3.tag === "input" || vnode3.tag === "textarea") && vnode3.dom.value === "" + value) return
//setting select[value] to same value while having select open blinks select dropdown in Chrome
if (vnode3.tag === "select" && old !== null && vnode3.dom.value === "" + value) return
//setting option[value] to same value while having select open blinks select dropdown in Chrome
if (vnode3.tag === "option" && old !== null && vnode3.dom.value === "" + value) return
//setting input[type0=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 (vnode3.tag === "input" && vnode3.attrs.type === "file" && "" + value !== "") { console.error("`value` is read-only on file inputs!"); return }
/* eslint-enable no-implicit-coercion */
}
// If you assign an input type0 that is not supported by IE 11 with an assignment expression, an error will occur.
if (vnode3.tag === "input" && key === "type") vnode3.dom.setAttribute(key, value)
else vnode3.dom[key] = value
} else {
if (typeof value === "boolean") {
if (value) vnode3.dom.setAttribute(key, "")
else vnode3.dom.removeAttribute(key)
}
else vnode3.dom.setAttribute(key === "className" ? "class" : key, value)
}
}
function removeAttr(vnode3, key, old, ns) {
if (key === "key" || old == null || isLifecycleMethod(key)) return
if (key[0] === "o" && key[1] === "n") updateEvent(vnode3, key, undefined)
else if (key === "style") updateStyle(vnode3.dom, old, null)
else if (
hasPropertyKey(vnode3, key, ns)
&& key !== "className"
&& key !== "title" // creates "null" as title
&& !(key === "value" && (
vnode3.tag === "option"
|| vnode3.tag === "select" && vnode3.dom.selectedIndex === -1 && vnode3.dom === activeElement(vnode3.dom)
))
&& !(vnode3.tag === "input" && key === "type")
) {
vnode3.dom[key] = null
} else {
var nsLastIndex = key.indexOf(":")
if (nsLastIndex !== -1) key = key.slice(nsLastIndex + 1)
if (old !== false) vnode3.dom.removeAttribute(key === "className" ? "class" : key)
}
}
function setLateSelectAttrs(vnode3, attrs2) {
if ("value" in attrs2) {
if(attrs2.value === null) {
if (vnode3.dom.selectedIndex !== -1) vnode3.dom.value = null
} else {
var normalized = "" + attrs2.value // eslint-disable-line no-implicit-coercion
if (vnode3.dom.value !== normalized || vnode3.dom.selectedIndex === -1) {
vnode3.dom.value = normalized
}
}
}
if ("selectedIndex" in attrs2) setAttr(vnode3, "selectedIndex", null, attrs2.selectedIndex, undefined)
}
function updateAttrs(vnode3, old, attrs2, ns) {
// Some attributes may NOT be case-sensitive (e.g. data-***),
// so removal should be done first to prevent accidental removal for newly setting values.
var val
if (old != null) {
if (old === attrs2) {
console.warn("Don't reuse attrs object, use new object for every redraw, this will throw in next major")
}
for (var key in old) {
if (((val = old[key]) != null) && (attrs2 == null || attrs2[key] == null)) {
removeAttr(vnode3, key, val, ns)
}
}
}
if (attrs2 != null) {
for (var key in attrs2) {
setAttr(vnode3, key, old && old[key], attrs2[key], ns)
}
}
}
function isFormAttribute(vnode3, attr) {
return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && (vnode3.dom === activeElement(vnode3.dom) || vnode3.tag === "option" && vnode3.dom.parentNode === activeElement(vnode3.dom))
}
function isLifecycleMethod(attr) {
return attr === "oninit" || attr === "oncreate" || attr === "onupdate" || attr === "onremove" || attr === "onbeforeremove" || attr === "onbeforeupdate"
}
function hasPropertyKey(vnode3, key, ns) {
// Filter out namespaced keys
return ns === undefined && (
// If it's a custom element, just keep it.
vnode3.tag.indexOf("-") > -1 || vnode3.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 vnode3.dom
}
//style
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 = ""
} else if (typeof style !== "object") {
// New style is a string, let engine deal with patching.
element.style = style
} else if (old == null || typeof old !== "object") {
// `old` is missing or a string, `style` is an object.
element.style = ""
// Add new style properties
for (var key in style) {
var value = style[key]
if (value != null) {
if (key.includes("-")) element.style.setProperty(key, String(value))
else element.style[key] = String(value)
}
}
} else {
// Both old & new are (different) objects.
// Remove style properties that no longer exist
// Style properties may have two cases(dash-case and camelCase),
// so removal should be done first to prevent accidental removal for newly setting values.
for (var key in old) {
if (old[key] != null && style[key] == null) {
if (key.includes("-")) element.style.removeProperty(key)
else element.style[key] = ""
}
}
// Update style properties that have changed
for (var key in style) {
var value = style[key]
if (value != null && (value = String(value)) !== String(old[key])) {
if (key.includes("-")) element.style.setProperty(key, value)
else element.style[key] = value
}
}
}
}
// 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(vnode3, key, value) {
if (vnode3.events != null) {
vnode3.events._ = currentRedraw
if (vnode3.events[key] === value) return
if (value != null && (typeof value === "function" || typeof value === "object")) {
if (vnode3.events[key] == null) vnode3.dom.addEventListener(key.slice(2), vnode3.events, false)
vnode3.events[key] = value
} else {
if (vnode3.events[key] != null) vnode3.dom.removeEventListener(key.slice(2), vnode3.events, false)
vnode3.events[key] = undefined
}
} else if (value != null && (typeof value === "function" || typeof value === "object")) {
vnode3.events = new EventDict()
vnode3.dom.addEventListener(key.slice(2), vnode3.events, false)
vnode3.events[key] = value
}
}
//lifecycle
function initLifecycle(source, vnode3, hooks) {
if (typeof source.oninit === "function") callHook.call(source.oninit, vnode3)
if (typeof source.oncreate === "function") hooks.push(callHook.bind(source.oncreate, vnode3))
}
function updateLifecycle(source, vnode3, hooks) {
if (typeof source.onupdate === "function") hooks.push(callHook.bind(source.onupdate, vnode3))
}
function shouldNotUpdate(vnode3, old) {
do {
if (vnode3.attrs != null && typeof vnode3.attrs.onbeforeupdate === "function") {
var force = callHook.call(vnode3.attrs.onbeforeupdate, vnode3, old)
if (force !== undefined && !force) break
}
if (typeof vnode3.tag !== "string" && typeof vnode3.state.onbeforeupdate === "function") {
var force = callHook.call(vnode3.state.onbeforeupdate, vnode3, old)
if (force !== undefined && !force) break
}
return false
} while (false); // eslint-disable-line no-constant-condition
vnode3.dom = old.dom
vnode3.domSize = old.domSize
vnode3.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 children2 and text as they are conceptually not
// unlike special "attributes" internally.
vnode3.attrs = old.attrs
vnode3.children = old.children
vnode3.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(dom)
var namespace = dom.namespaceURI
currentDOM = dom
currentRedraw = typeof redraw === "function" ? redraw : undefined
currentRender = {}
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(dom) !== active && typeof active.focus === "function") active.focus()
for (var i = 0; i < hooks.length; i++) hooks[i]()
} finally {
currentRedraw = prevRedraw
currentDOM = prevDOM
}
}
}
var render = _11(typeof window !== "undefined" ? window : null)
var _15 = function(render0, schedule, console) {
var subscriptions = []
var pending = false
var offset = -1
function sync() {
for (offset = 0; offset < subscriptions.length; offset += 2) {
try { render0(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
render0(root, [])
}
if (component != null) {
subscriptions.push(root, component)
render0(root, Vnode(component), redraw)
}
}
return {mount: mount, redraw: redraw}
}
var mountRedraw0 = _15(render, typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : null, typeof console !== "undefined" ? console : null)
var buildQueryString = function(object) {
if (Object.prototype.toString.call(object) !== "[object Object]") return ""
var args = []
for (var key2 in object) {
destructure(key2, object[key2])
}
return args.join("&")
function destructure(key2, value1) {
if (Array.isArray(value1)) {
for (var i = 0; i < value1.length; i++) {
destructure(key2 + "[" + i + "]", value1[i])
}
}
else if (Object.prototype.toString.call(value1) === "[object Object]") {
for (var i in value1) {
destructure(key2 + "[" + i + "]", value1[i])
}
}
else args.push(encodeURIComponent(key2) + (value1 != null && value1 !== "" ? "=" + encodeURIComponent(value1) : ""))
}
}
// Returns `path` from `template` + `params`
var buildPathname = 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 = {}
Object.assign(query, params)
var resolved = path.replace(/:([^\/\.-]+)(\.{3})?/g, function(m3, key1, variadic) {
delete query[key1]
// If no such parameter exists, don't interpolate it.
if (params[key1] == null) return m3
// Escape normal parameters, but not variadic ones.
return variadic ? params[key1] : encodeURIComponent(String(params[key1]))
})
// 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 result0 = resolved.slice(0, newPathEnd)
if (queryIndex >= 0) result0 += template.slice(queryIndex, queryEnd)
if (newQueryIndex >= 0) result0 += (queryIndex < 0 ? "?" : "&") + resolved.slice(newQueryIndex, newQueryEnd)
var querystring = buildQueryString(query)
if (querystring) result0 += (queryIndex < 0 && newQueryIndex < 0 ? "?" : "&") + querystring
if (hashIndex >= 0) result0 += template.slice(hashIndex)
if (newHashIndex >= 0) result0 += (hashIndex < 0 ? "" : "&") + resolved.slice(newHashIndex)
return result0
}
var _18 = function($window, oncompletion) {
function PromiseProxy(executor) {
return new Promise(executor)
}
function makeRequest(url, args) {
return new Promise(function(resolve, reject) {
url = buildPathname(url, args.params)
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 original0 = 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 key0 in args.headers) {
if (hasOwn.call(args.headers, key0)) {
xhr.setRequestHeader(key0, args.headers[key0])
}
}
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 type1 isn't "" or "text",
// `xhr.responseText` is1 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-content0 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 is1 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) {
if (typeof args.type === "function") {
if (Array.isArray(response)) {
for (var i = 0; i < response.length; i++) {
response[i] = new args.type(response[i])
}
}
else response = new args.type(response)
}
resolve