summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorthe lemons <citrons@mondecitronne.com>2021-03-30 22:09:57 -0500
committerthe lemons <citrons@mondecitronne.com>2021-03-30 22:09:57 -0500
commit3ad03980ea38443680aa85fdb53b1b6a3001e150 (patch)
treed16db79d70a6e72fd73a72fb75be26c5de78b145
parentb35ac965d63d831653e940a862689fb48d91901e (diff)
all shall submit to QOL. also, other cleanup things
Diffstat
-rw-r--r--game.js12
-rw-r--r--index.html3
-rw-r--r--mithril.js1842
3 files changed, 1853 insertions, 4 deletions
diff --git a/game.js b/game.js
index b8e6d32..a8c8eb5 100644
--- a/game.js
+++ b/game.js
@@ -51,7 +51,9 @@
var ThingButton = {
view: ()=>{
- return m("button",{onclick:()=>{if (!sdata.autothing) am.thing.amount+=1}},sdata.autothing?"Unavailable":"Attain a thing");
+ return m("button",{
+ onclick:()=>{if (!sdata.autothing) am.thing.amount+=1}
+ },sdata.autothing?"Unavailable":"Attain a thing");
}
}
@@ -59,7 +61,9 @@
view: ()=>{
return m("button",{onclick:()=>sdata.autothing = !sdata.autothing},[
"AutoThing™ ",
- m("span",{style:"color:"+(sdata.autothing?"lime":"grey")+";"},sdata.autothing?"ON":"OFF"),
+ m("span",{
+ style:"color:"+(sdata.autothing?"lime":"grey")+";"},
+ sdata.autothing?"ON":"OFF"),
]);
}
}
@@ -109,7 +113,9 @@
let a = vnode.attrs;
return m(".currencydisplay",[
m(CIcon,{currency:a.currency}),
- m(".currencycount",{style:"color:"+cdata[a.currency].color},a.amount==undefined?"oh bee something broke":a.amount),
+ m(".currencycount",{
+ style:"color:"+cdata[a.currency].color},
+ a.amount==undefined?"oh bee something broke":a.amount),
]);
}
}
diff --git a/index.html b/index.html
index 140d1cb..5305b13 100644
--- a/index.html
+++ b/index.html
@@ -1,5 +1,6 @@
<html>
<head>
+ <meta charset="utf8"></meta>
<style>
body {
color:#FFF;
@@ -43,7 +44,7 @@
</style>
</head>
<body>
- <script src="https://unpkg.com/mithril/mithril.js"></script>
+ <script src="mithril.js"></script>
<script src="game.js"></script>
</body>
</html>
diff --git a/mithril.js b/mithril.js
new file mode 100644
index 0000000..377e0a5
--- /dev/null
+++ b/mithril.js
@@ -0,0 +1,1842 @@
+;(function() {
+"use strict"
+function Vnode(tag, key, attrs0, children0, text, dom) {
+ return {tag: tag, key: key, attrs: attrs0, children: children0, 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 children0 = []
+ 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("Vnodes must either always have keys or never have keys!")
+ }
+ }
+ for (var i = 0; i < input.length; i++) {
+ children0[i] = Vnode.normalize(input[i])
+ }
+ }
+ return children0
+}
+// 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 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, ...children1) {
+// if (attrs1 == null || typeof attrs1 === "object" && attrs1.tag == null && !Array.isArray(attrs1)) {
+// if (children1.length === 1 && Array.isArray(children1[0])) children1 = children1[0]
+// } else {
+// children1 = children1.length === 0 && Array.isArray(attrs1) ? attrs1 : [attrs1, ...children1]
+// attrs1 = undefined
+// }
+//
+// if (attrs1 == null) attrs1 = {}
+// return Vnode("", attrs1.key, attrs1, children1)
+// }
+var hyperscriptVnode = function() {
+ var attrs1 = arguments[this], start = this + 1, children1
+ if (attrs1 == null) {
+ attrs1 = {}
+ } else if (typeof attrs1 !== "object" || attrs1.tag != null || Array.isArray(attrs1)) {
+ attrs1 = {}
+ start = this
+ }
+ if (arguments.length === start + 1) {
+ children1 = arguments[start]
+ if (!Array.isArray(children1)) children1 = [children1]
+ } else {
+ children1 = []
+ while (start < arguments.length) children1.push(arguments[start++])
+ }
+ return Vnode("", attrs1.key, attrs1, children1)
+}
+var selectorParser = /(?:(^|#|\.)([^#\.\[\]]+))|(\[(.+?)(?:\s*=\s*("|'|)((?:\\["'\]]|.)*?)\5)?\])/g
+var selectorCache = {}
+var hasOwn = {}.hasOwnProperty
+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 children = Vnode.normalizeChildren(vnode.children)
+ var hasClass = hasOwn.call(attrs, "class")
+ var className = hasClass ? attrs.class : attrs.className
+ vnode.tag = state.tag
+ vnode.attrs = null
+ vnode.children = undefined
+ 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
+ }
+ }
+ if (Array.isArray(children) && children.length === 1 && children[0] != null && children[0].tag === "#") {
+ vnode.text = children[0].children
+ } else {
+ vnode.children = children
+ }
+ 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
+}
+/** @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 w/ 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)
+ }
+ })
+}
+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
+ }
+ var PromisePolyfill = 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
+ }
+ var PromisePolyfill = global.Promise
+} else {
+}
+var _12 = 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(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() {
+ 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 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 = $doc.createTextNode(vnode3.children)
+ insertNode(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 = $doc.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.
+ vnode3.instance = []
+ var fragment = $doc.createDocumentFragment()
+ var child
+ while (child = temp.firstChild) {
+ vnode3.instance.push(child)
+ fragment.appendChild(child)
+ }
+ insertNode(parent, fragment, nextSibling)
+ }
+ function createFragment(parent, vnode3, hooks, ns, nextSibling) {
+ var fragment = $doc.createDocumentFragment()
+ if (vnode3.children != null) {
+ var children3 = vnode3.children
+ createNodes(fragment, children3, 0, children3.length, hooks, null, ns)
+ }
+ vnode3.dom = fragment.firstChild
+ vnode3.domSize = fragment.childNodes.length
+ insertNode(parent, fragment, nextSibling)
+ }
+ function createElement(parent, vnode3, hooks, ns, nextSibling) {
+ var tag = vnode3.tag
+ var attrs2 = vnode3.attrs
+ var is = attrs2 && attrs2.is
+ ns = getNameSpace(vnode3) || ns
+ var element = ns ?
+ is ? $doc.createElementNS(ns, tag, {is: is}) : $doc.createElementNS(ns, tag) :
+ is ? $doc.createElement(tag, {is: is}) : $doc.createElement(tag)
+ vnode3.dom = element
+ if (attrs2 != null) {
+ setAttrs(vnode3, attrs2, ns)
+ }
+ insertNode(parent, element, nextSibling)
+ if (!maybeSetContentEditable(vnode3)) {
+ if (vnode3.text != null) {
+ if (vnode3.text !== "") element.textContent = vnode3.text
+ else vnode3.children = [Vnode("#", undefined, undefined, vnode3.text, undefined, undefined)]
+ }
+ if (vnode3.children != null) {
+ var children3 = vnode3.children
+ createNodes(element, children3, 0, children3.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), then0 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 runs0 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 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 (isKeyed0 === null && isOldKeyed == null) return // both lists are full of nulls
+ 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)
+ 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, vnode3, hooks, nextSibling, ns) {
+ var oldTag = old.tag, tag = vnode3.tag
+ if (oldTag === tag) {
+ 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) {
+ removeHTML(parent, old)
+ createHTML(parent, vnode3, ns, nextSibling)
+ }
+ else {
+ vnode3.dom = old.dom
+ vnode3.domSize = old.domSize
+ vnode3.instance = old.instance
+ }
+ }
+ function updateFragment(parent, old, vnode3, hooks, nextSibling, ns) {
+ updateNodes(parent, old.children, vnode3.children, hooks, nextSibling, ns)
+ var domSize = 0, children3 = vnode3.children
+ vnode3.dom = null
+ if (children3 != null) {
+ for (var i = 0; i < children3.length; i++) {
+ var child = children3[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
+ if (vnode3.tag === "textarea") {
+ if (vnode3.attrs == null) vnode3.attrs = {}
+ if (vnode3.text != null) {
+ vnode3.attrs.value = vnode3.text //FIXME handle0 multiple children3
+ vnode3.text = undefined
+ }
+ }
+ updateAttrs(vnode3, old.attrs, vnode3.attrs, ns)
+ if (!maybeSetContentEditable(vnode3)) {
+ if (old.text != null && vnode3.text != null && vnode3.text !== "") {
+ if (old.text.toString() !== vnode3.text.toString()) old.dom.firstChild.nodeValue = vnode3.text
+ }
+ else {
+ if (old.text != null) old.children = [Vnode("#", undefined, undefined, old.text, undefined, old.dom.firstChild)]
+ if (vnode3.text != null) vnode3.children = [Vnode("#", undefined, undefined, vnode3.text, undefined, undefined)]
+ 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
+ // subsequece
+ 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 promise0 in `onbeforeremove`
+ // - Parent node is moved in keyed diff
+ // - Remaining children3 still need moved appropriately
+ //
+ // Ideally, I'd track removed nodes as well, but that introduces a lot more
+ // complexity and I'm0 not exactly interested in doing that.
+ function moveNodes(parent, vnode3, nextSibling) {
+ var frag = $doc.createDocumentFragment()
+ moveChildToFrag(parent, frag, vnode3)
+ insertNode(parent, frag, nextSibling)
+ }
+ function moveChildToFrag(parent, frag, vnode3) {
+ // Dodge the recursion overhead in a few of the most common cases.
+ while (vnode3.dom != null && vnode3.dom.parentNode === parent) {
+ if (typeof vnode3.tag !== "string") {
+ vnode3 = vnode3.instance
+ if (vnode3 != null) continue
+ } else if (vnode3.tag === "<") {
+ for (var i = 0; i < vnode3.instance.length; i++) {
+ frag.appendChild(vnode3.instance[i])
+ }
+ } else if (vnode3.tag !== "[") {
+ // Don't recurse for text nodes *or* elements, just fragments
+ frag.appendChild(vnode3.dom)
+ } else if (vnode3.children.length === 1) {
+ vnode3 = vnode3.children[0]
+ if (vnode3 != null) continue
+ } else {
+ for (var i = 0; i < vnode3.children.length; i++) {
+ var child = vnode3.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(vnode3) {
+ if (vnode3.attrs == null || (
+ vnode3.attrs.contenteditable == null && // attribute
+ vnode3.attrs.contentEditable == null // property
+ )) return false
+ var children3 = vnode3.children
+ if (children3 != null && children3.length === 1 && children3[0].tag === "<") {
+ var content = children3[0].children
+ if (vnode3.dom.innerHTML !== content) vnode3.dom.innerHTML = content
+ }
+ else if (vnode3.text != null || children3 != null && children3.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 removeNode(parent, vnode3) {
+ var mask = 0
+ var original = vnode3.state
+ var stateResult, attrsResult
+ if (typeof vnode3.tag !== "string" && typeof vnode3.state.onbeforeremove === "function") {
+ var result = callHook.call(vnode3.state.onbeforeremove, vnode3)
+ if (result != null && typeof result.then === "function") {
+ mask = 1
+ stateResult = result
+ }
+ }
+ if (vnode3.attrs && typeof vnode3.attrs.onbeforeremove === "function") {
+ var result = callHook.call(vnode3.attrs.onbeforeremove, vnode3)
+ if (result != null && typeof result.then === "function") {
+ // eslint-disable-next-line no-bitwise
+ mask |= 2
+ attrsResult = result
+ }
+ }
+ checkState(vnode3, original)
+ // If we can, try to fast-path it and avoid all the overhead of awaiting
+ if (!mask) {
+ onremove(vnode3)
+ removeChild(parent, vnode3)
+ } 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(vnode3, original)
+ onremove(vnode3)
+ removeChild(parent, vnode3)
+ }
+ }
+ function removeHTML(parent, vnode3) {
+ for (var i = 0; i < vnode3.instance.length; i++) {
+ parent.removeChild(vnode3.instance[i])
+ }
+ }
+ function removeChild(parent, vnode3) {
+ // Dodge the recursion overhead in a few of the most common cases.
+ while (vnode3.dom != null && vnode3.dom.parentNode === parent) {
+ if (typeof vnode3.tag !== "string") {
+ vnode3 = vnode3.instance
+ if (vnode3 != null) continue
+ } else if (vnode3.tag === "<") {
+ removeHTML(parent, vnode3)
+ } else {
+ if (vnode3.tag !== "[") {
+ parent.removeChild(vnode3.dom)
+ if (!Array.isArray(vnode3.children)) break
+ }
+ if (vnode3.children.length === 1) {
+ vnode3 = vnode3.children[0]
+ if (vnode3 != null) continue
+ } else {
+ for (var i = 0; i < vnode3.children.length; i++) {
+ var child = vnode3.children[i]
+ if (child != null) removeChild(parent, child)
+ }
+ }
+ }
+ break
+ }
+ }
+ 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 children3 = vnode3.children
+ if (Array.isArray(children3)) {
+ for (var i = 0; i < children3.length; i++) {
+ var child = children3[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" || key === "is" || 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
+ if ((vnode3.tag === "input" || vnode3.tag === "textarea") && vnode3.dom.value === "" + value && vnode3.dom === activeElement()) 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
+ /* 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" || key === "is" || old == null || isLifecycleMethod(key)) return
+ if (key[0] === "o" && key[1] === "n" && !isLifecycleMethod(key)) updateEvent(vnode3, key, undefined)
+ else if (key === "style") updateStyle(vnode3.dom, old, null)
+ else if (
+ hasPropertyKey(vnode3, key, ns)
+ && key !== "className"
+ && !(key === "value" && (
+ vnode3.tag === "option"
+ || vnode3.tag === "select" && vnode3.dom.selectedIndex === -1 && vnode3.dom === activeElement()
+ ))
+ && !(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) {
+ if (attrs2 != null) {
+ for (var key in attrs2) {
+ setAttr(vnode3, key, old && old[key], attrs2[key], ns)
+ }
+ }
+ var val
+ if (old != null) {
+ for (var key in old) {
+ if (((val = old[key]) != null) && (attrs2 == null || attrs2[key] == null)) {
+ removeAttr(vnode3, key, val, ns)
+ }
+ }
+ }
+ }
+ function isFormAttribute(vnode3, attr) {
+ return attr === "value" || attr === "checked" || attr === "selectedIndex" || attr === "selected" && vnode3.dom === activeElement() || vnode3.tag === "option" && vnode3.dom.parentNode === $doc.activeElement
+ }
+ 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.attrs != null && vnode3.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 vnode3.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 handler0 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 handler0 = this["on" + ev.type]
+ var result
+ if (typeof handler0 === "function") result = handler0.call(ev.currentTarget, ev)
+ else if (typeof handler0.handleEvent === "function") handler0.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) {
+ 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 children3 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
+ }
+ return function(dom, vnodes, redraw) {
+ if (!dom) throw new TypeError("Ensure the DOM element being passed to m.route/m.mount/m.render is not undefined.")
+ var hooks = []
+ var active = activeElement()
+ var namespace = dom.namespaceURI
+ // First time rendering into a node clears it out
+ if (dom.vnodes == null) dom.textContent = ""
+ vnodes = Vnode.normalizeChildren(Array.isArray(vnodes) ? vnodes : [vnodes])
+ var prevRedraw = currentRedraw
+ try {
+ currentRedraw = typeof redraw === "function" ? redraw : undefined
+ updateNodes(dom, dom.vnodes, vnodes, hooks, null, namespace === "http://www.w3.org/1999/xhtml" ? undefined : namespace)
+ } finally {
+ currentRedraw = prevRedraw
+ }
+ 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]()
+ }
+}
+var render = _12(window)
+var _15 = function(render0, schedule, console) {
+ var subscriptions = []
+ var rendering = false
+ var pending = false
+ function sync() {
+ if (rendering) throw new Error("Nested m.redraw.sync() call")
+ rendering = true
+ for (var i = 0; i < subscriptions.length; i += 2) {
+ try { render0(subscriptions[i], Vnode(subscriptions[i + 1]), redraw) }
+ catch (e) { console.error(e) }
+ }
+ rendering = false
+ }
+ 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(element, component) expects a component, not a vnode")
+ }
+ var index = subscriptions.indexOf(root)
+ if (index >= 0) {
+ subscriptions.splice(index, 2)
+ render0(root, [], redraw)
+ }
+ if (component != null) {
+ subscriptions.push(root, component)
+ render0(root, Vnode(component), redraw)
+ }
+ }
+ return {mount: mount, redraw: redraw}
+}
+var mountRedraw0 = _15(render, requestAnimationFrame, console)
+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) : ""))
+ }
+}
+var assign = Object.assign || function(target, source) {
+ if(source) Object.keys(source).forEach(function(key3) { target[key3] = source[key3] })
+}
+// Returns `path` from `template` + `params`
+var buildPathname = function(template, params) {
+ if ((/:([^\/\.-]+)(\.{3})?:/).test(template)) {
+ throw new SyntaxError("Template parameter names *must* be separated")
+ }
+ 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(m2, key1, variadic) {
+ delete query[key1]
+ // If no such parameter exists, don't interpolate it.
+ if (params[key1] == null) return m2
+ // 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, Promise, oncompletion) {
+ var callbackCount = 0
+ function PromiseProxy(executor) {
+ return new Promise(executor)
+ }
+ // In case the global Promise is0 some userland library's where they rely on
+ // `foo instanceof this.constructor`, `this.constructor.resolve(value0)`, 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 promise1 = 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 promise1
+ var count = 0
+ function complete() {
+ if (--count === 0 && typeof oncompletion === "function") oncompletion()
+ }
+ return wrap(promise1)
+ function wrap(promise1) {
+ var then1 = promise1.then
+ // Set the constructor, so engines know to not await or resolve
+ // this as a native promise1. At the time of writing, this is0
+ // only necessary for V8, but their behavior is0 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 `request0/tests/test-request0.js` for
+ // a bit more background on the issue at hand.
+ promise1.constructor = PromiseProxy
+ promise1.then = function() {
+ count++
+ var next0 = then1.apply(promise1, arguments)
+ next0.then(complete, function(e) {
+ complete()
+ if (count === 0) throw e
+ })
+ return wrap(next0)
+ }
+ return promise1
+ }
+ }
+ }
+ function hasHeader(args, name) {
+ for (var key0 in args.headers) {
+ if ({}.hasOwnProperty.call(args.headers, key0) && name.test(key0)) 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)
+ var responseType = args.responseType || (typeof args.extract === "function" ? "" : "json")
+ var xhr = new $window.XMLHttpRequest(), aborted = 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, /^content0-type1$/i)) {
+ xhr.setRequestHeader("Content-Type", "application/json; charset=utf-8")
+ }
+ if (typeof args.deserialize !== "function" && !hasHeader(args, /^accept$/i)) {
+ 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 ({}.hasOwnProperty.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` is0 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") response = JSON.parse(ev.target.responseText)
+ } else if (!responseType || responseType === "text") {
+ // Only use this default if it's text. If a parsed
+ // document is0 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 {
+ try { message = ev.target.responseText }
+ catch (e) { message = response }
+ var error = new Error(message)
+ error.code = ev.target.status
+ error.response = response
+ reject(error)
+ }
+ }
+ catch (e) {
+ reject(e)
+ }
+ }
+ }
+ if (typeof args.config === "function") {
+ xhr = args.config(xhr, args, url) || xhr
+ // Propagate the `abort` to any replacement XHR as well.
+ if (xhr !== original0) {
+ 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) 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)
+ }),
+ }
+}
+var request = _18(window, PromisePolyfill, mountRedraw0.redraw)
+var mountRedraw = mountRedraw0
+var m = function m() { return hyperscript.apply(this, arguments) }
+m.m = hyperscript
+m.trust = hyperscript.trust
+m.fragment = hyperscript.fragment
+m.mount = mountRedraw.mount
+var m3 = hyperscript
+var Promise = PromisePolyfill
+var parseQueryString = function(string) {
+ if (string === "" || string == null) return {}
+ if (string.charAt(0) === "?") string = string.slice(1)
+ var entries = string.split("&"), counters = {}, data0 = {}
+ for (var i = 0; i < entries.length; i++) {
+ var entry = entries[i].split("=")
+ var key5 = decodeURIComponent(entry[0])
+ var value2 = entry.length === 2 ? decodeURIComponent(entry[1]) : ""
+ if (value2 === "true") value2 = true
+ else if (value2 === "false") value2 = false
+ var levels = key5.split(/\]\[?|\[/)
+ var cursor = data0
+ if (key5.indexOf("[") > -1) levels.pop()
+ for (var j0 = 0; j0 < levels.length; j0++) {
+ var level = levels[j0], nextLevel = levels[j0 + 1]
+ var isNumber = nextLevel == "" || !isNaN(parseInt(nextLevel, 10))
+ if (level === "") {
+ var key5 = levels.slice(0, j0).join()
+ if (counters[key5] == null) {
+ counters[key5] = Array.isArray(cursor) ? cursor.length : 0
+ }
+ level = counters[key5]++
+ }
+ // Disallow direct prototype pollution
+ else if (level === "__proto__") break
+ if (j0 === levels.length - 1) cursor[level] = value2
+ 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 data0
+}
+// Returns `{path1, params}` from `url`
+var parsePathname = function(url) {
+ var queryIndex0 = url.indexOf("?")
+ var hashIndex0 = url.indexOf("#")
+ var queryEnd0 = hashIndex0 < 0 ? url.length : hashIndex0
+ var pathEnd0 = queryIndex0 < 0 ? queryEnd0 : queryIndex0
+ var path1 = url.slice(0, pathEnd0).replace(/\/{2,}/g, "/")
+ if (!path1) path1 = "/"
+ else {
+ if (path1[0] !== "/") path1 = "/" + path1
+ if (path1.length > 1 && path1[path1.length - 1] === "/") path1 = path1.slice(0, -1)
+ }
+ return {
+ path: path1,
+ params: queryIndex0 < 0
+ ? {}
+ : parseQueryString(url.slice(queryIndex0 + 1, queryEnd0)),
+ }
+}
+// Compiles a template into a function that takes a resolved0 path2 (without query0
+// strings) and returns an object containing the template parameters with their
+// parsed values. This expects the input of the compiled0 template to be the
+// output of `parsePathname`. Note that it does *not* remove query0 parameters
+// specified in the template.
+var compileTemplate = 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 is2 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(m4, key6, extra) {
+ if (key6 == null) return "\\" + m4
+ keys.push({k: key6, r: extra === "..."})
+ if (extra === "...") return "(.*)"
+ if (extra === ".") return "([^/]+)\\."
+ return "([^/]+)" + (extra || "")
+ }
+ ) + "$")
+ return function(data1) {
+ // 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]] !== data1.params[templateKeys[i]]) return false
+ }
+ // If no interpolations exist, let's skip all the ceremony
+ if (!keys.length) return regexp.test(data1.path)
+ var values = regexp.exec(data1.path)
+ if (values == null) return false
+ for (var i = 0; i < keys.length; i++) {
+ data1.params[keys[i].k] = keys[i].r ? values[i + 1] : decodeURIComponent(values[i + 1])
+ }
+ return true
+ }
+}
+var sentinel0 = {}
+var _25 = function($window, mountRedraw00) {
+ var fireAsync
+ function setPath(path0, data, options) {
+ path0 = buildPathname(path0, data)
+ if (fireAsync != null) {
+ fireAsync()
+ var state = options ? options.state : null
+ var title = options ? options.title : null
+ if (options && options.replace) $window.history.replaceState(state, title, route.prefix + path0)
+ else $window.history.pushState(state, title, route.prefix + path0)
+ }
+ else {
+ $window.location.href = route.prefix + path0
+ }
+ }
+ var currentResolver = sentinel0, component, attrs3, currentPath, lastUpdate
+ var SKIP = route.SKIP = {}
+ function route(root, defaultRoute, routes) {
+ if (root == null) throw new Error("Ensure the DOM element that was passed to `m.route` is not undefined")
+ // 0 = start0
+ // 1 = init
+ // 2 = ready
+ var state = 0
+ var 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),
+ }
+ })
+ var callAsync0 = typeof setImmediate === "function" ? setImmediate : setTimeout
+ var p = Promise.resolve()
+ var scheduled = false
+ var onremove0
+ fireAsync = null
+ 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")
+ }
+ }
+ 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 is1 consistently a relatively poorly
+ // optimized cons string.
+ var path0 = prefix.concat()
+ .replace(/(?:%[a-f89][a-f0-9])+/gim, decodeURIComponent)
+ .slice(route.prefix.length)
+ var data = parsePathname(path0)
+ assign(data.params, $window.history.state)
+ function fail() {
+ if (path0 === defaultRoute) throw new Error("Could not resolve default route " + defaultRoute)
+ setPath(defaultRoute, null, {replace: true})
+ }
+ loop(0)
+ function loop(i) {
+ // 0 = init
+ // 1 = scheduled
+ // 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"
+ attrs3 = data.params, currentPath = path0, lastUpdate = null
+ currentResolver = payload.render ? payload : null
+ if (state === 2) mountRedraw00.redraw()
+ else {
+ state = 2
+ mountRedraw00.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, path0, matchedRoute)
+ }).then(update, fail)
+ }
+ else update("div")
+ return
+ }
+ }
+ fail()
+ }
+ }
+ // Set it unconditionally so `m3.route.set` and `m3.route.Link` both work,
+ // even if neither `pushState` nor `hashchange` are supported. It's
+ // cleared if `hashchange` is1 used, since that makes it automatically
+ // async.
+ fireAsync = function() {
+ if (!scheduled) {
+ scheduled = true
+ callAsync0(resolveRoute)
+ }
+ }
+ if (typeof $window.history.pushState === "function") {
+ onremove0 = function() {
+ $window.removeEventListener("popstate", fireAsync, false)
+ }
+ $window.addEventListener("popstate", fireAsync, false)
+ } else if (route.prefix[0] === "#") {
+ fireAsync = null
+ onremove0 = function() {
+ $window.removeEventListener("hashchange", resolveRoute, false)
+ }
+ $window.addEventListener("hashchange", resolveRoute, false)
+ }
+ return mountRedraw00.mount(root, {
+ onbeforeupdate: function() {
+ state = state ? 2 : 1
+ return !(!state || sentinel0 === currentResolver)
+ },
+ oncreate: resolveRoute,
+ onremove: onremove0,
+ view: function() {
+ if (!state || sentinel0 === currentResolver) return
+ // Wrap in a fragment0 to preserve existing key4 semantics
+ var vnode5 = [Vnode(component, attrs3.key, attrs3)]
+ if (currentResolver) vnode5 = currentResolver.render(vnode5[0])
+ return vnode5
+ },
+ })
+ }
+ route.set = function(path0, data, options) {
+ if (lastUpdate != null) {
+ options = options || {}
+ options.replace = true
+ }
+ lastUpdate = null
+ setPath(path0, data, options)
+ }
+ route.get = function() {return currentPath}
+ route.prefix = "#!"
+ route.Link = {
+ view: function(vnode5) {
+ var options = vnode5.attrs.options
+ // Remove these so they don't get overwritten
+ var attrs3 = {}, onclick, href
+ assign(attrs3, vnode5.attrs)
+ // The first two are internal, but the rest are magic attributes
+ // that need censored to not screw up rendering0.
+ attrs3.selector = attrs3.options = attrs3.key = attrs3.oninit =
+ attrs3.oncreate = attrs3.onbeforeupdate = attrs3.onupdate =
+ attrs3.onbeforeremove = attrs3.onremove = null
+ // Do this now so we can get the most current `href` and `disabled`.
+ // Those attributes may also be specified in the selector, and we
+ // should honor that.
+ var child0 = m3(vnode5.attrs.selector || "a", attrs3, vnode5.children)
+ // Let's provide a *right* way to disable a route link, rather than
+ // letting people screw up accessibility on accident.
+ //
+ // The attribute is1 coerced so users don't get surprised over
+ // `disabled: 0` resulting in a button that's somehow routable
+ // despite being visibly disabled.
+ if (child0.attrs.disabled = Boolean(child0.attrs.disabled)) {
+ child0.attrs.href = null
+ child0.attrs["aria-disabled"] = "true"
+ // If you *really* do want to do this on a disabled link, use
+ // an `oncreate` hook to add it.
+ child0.attrs.onclick = null
+ } else {
+ onclick = child0.attrs.onclick
+ href = child0.attrs.href
+ child0.attrs.href = route.prefix + href
+ child0.attrs.onclick = function(e) {
+ var result1
+ if (typeof onclick === "function") {
+ result1 = 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 handle1 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
+ result1 !== false && !e.defaultPrevented &&
+ // Ignore everything but left clicks
+ (e.button === 0 || e.which === 0 || e.which === 1) &&
+ // Let the browser handle1 `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 child0
+ },
+ }
+ route.param = function(key4) {
+ return attrs3 && key4 != null ? attrs3[key4] : attrs3
+ }
+ return route
+}
+m.route = _25(window, mountRedraw)
+m.render = render
+m.redraw = mountRedraw.redraw
+m.request = request.request
+m.jsonp = request.jsonp
+m.parseQueryString = parseQueryString
+m.buildQueryString = buildQueryString
+m.parsePathname = parsePathname
+m.buildPathname = buildPathname
+m.vnode = Vnode
+m.PromisePolyfill = PromisePolyfill
+if (typeof module !== "undefined") module["exports"] = m
+else window.m = m
+}()); \ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-29 13:30:09 +0000