{"mappings":"CAAC,SAAUA,EAAQC,GACI,iBAAZC,SAA0C,oBAAXC,OAAyBA,OAAOD,QAAUD,IAC9D,mBAAXG,QAAyBA,OAAOC,IAAMD,OAAOH,IACnDD,EAASA,GAAUM,MAAaC,SAAWN,GAChD,CAJC,CAICO,MAAM,WAAc,aAElB,IAgEIC,EACJ,IAAIC,EAAW,+BAEXC,EAA0B,oBAAbC,cAA2BC,EAAYD,SACpDE,IAAyBH,GAAO,YAAaA,EAAII,cAAc,YAC/DC,IAAsBL,GAAOA,EAAIM,aAAe,6BAA8BN,EAAIM,cAgCtF,SAASC,EAAUC,GAEf,OADAA,EAAMA,EAAIC,OACNN,EAhCR,SAAoCK,GAChC,IAAIE,EAAWV,EAAII,cAAc,YAEjC,OADAM,EAASC,UAAYH,EACdE,EAASE,QAAQC,WAAW,EACvC,CAgCaC,CAA2BN,GACzBH,EA/Bf,SAAiCG,GAO7B,OANKV,IACDA,EAAQE,EAAIM,eACNS,WAAWf,EAAIgB,MAGVlB,EAAMmB,yBAAyBT,GAC9BK,WAAW,EAC/B,CAwBaK,CAAwBV,GAtBrC,SAAgCA,GAC5B,IAAIW,EAAWnB,EAAII,cAAc,QAEjC,OADAe,EAASR,UAAYH,EACdW,EAASN,WAAW,EAC/B,CAqBWO,CAAuBZ,EAClC,CAYA,SAASa,EAAiBC,EAAQC,GAC9B,IAEIC,EAAeC,EAFfC,EAAeJ,EAAOK,SACtBC,EAAaL,EAAKI,SAGtB,OAAID,IAAiBE,IAIrBJ,EAAgBE,EAAaG,WAAW,GACxCJ,EAAcG,EAAWC,WAAW,GAMhCL,GAAiB,IAAMC,GAAe,GAC/BC,IAAiBE,EAAWE,cAC5BL,GAAe,IAAMD,GAAiB,IACtCI,IAAeF,EAAaI,cAI3C,CA8BA,SAASC,EAAoBT,EAAQC,EAAMS,GACnCV,EAAOU,KAAUT,EAAKS,KACtBV,EAAOU,GAAQT,EAAKS,GAChBV,EAAOU,GACPV,EAAOW,aAAaD,EAAM,IAE1BV,EAAOY,gBAAgBF,GAGnC,CAEA,IAAIG,EAAoB,CACpBC,OAAQ,SAASd,EAAQC,GACrB,IAAIc,EAAaf,EAAOe,WACxB,GAAIA,EAAY,CACZ,IAAIC,EAAaD,EAAWV,SAASG,cAClB,aAAfQ,IAEAA,GADAD,EAAaA,EAAWA,aACGA,EAAWV,SAASG,eAEhC,WAAfQ,GAA4BD,EAAWE,aAAa,cAChDjB,EAAOiB,aAAa,cAAgBhB,EAAKiB,WAIzClB,EAAOW,aAAa,WAAY,YAChCX,EAAOY,gBAAgB,aAK3BG,EAAWI,eAAgB,EAEnC,CACAV,EAAoBT,EAAQC,EAAM,WACtC,EAOAmB,MAAO,SAASpB,EAAQC,GACpBQ,EAAoBT,EAAQC,EAAM,WAClCQ,EAAoBT,EAAQC,EAAM,YAE9BD,EAAOqB,QAAUpB,EAAKoB,QACtBrB,EAAOqB,MAAQpB,EAAKoB,OAGnBpB,EAAKgB,aAAa,UACnBjB,EAAOY,gBAAgB,QAE/B,EAEAU,SAAU,SAAStB,EAAQC,GACvB,IAAIsB,EAAWtB,EAAKoB,MAChBrB,EAAOqB,QAAUE,IACjBvB,EAAOqB,MAAQE,GAGnB,IAAIC,EAAaxB,EAAOwB,WACxB,GAAIA,EAAY,CAGZ,IAAIC,EAAWD,EAAWE,UAE1B,GAAID,GAAYF,IAAcA,GAAYE,GAAYzB,EAAO2B,YACzD,OAGJH,EAAWE,UAAYH,CAC3B,CACJ,EACAK,OAAQ,SAAS5B,EAAQC,GACrB,IAAKA,EAAKgB,aAAa,YAAa,CAUhC,IATA,IAOIY,EACAxB,EARAc,GAAgB,EAChBW,EAAI,EAKJC,EAAW/B,EAAOwB,WAGhBO,GAEF,GAAiB,cADjB1B,EAAW0B,EAAS1B,UAAY0B,EAAS1B,SAASG,eAG9CuB,GADAF,EAAWE,GACSP,eACjB,CACH,GAAiB,WAAbnB,EAAuB,CACvB,GAAI0B,EAASd,aAAa,YAAa,CACnCE,EAAgBW,EAChB,KACJ,CACAA,GACJ,GACAC,EAAWA,EAASC,cACHH,IACbE,EAAWF,EAASG,YACpBH,EAAW,KAEnB,CAGJ7B,EAAOmB,cAAgBA,CAC3B,CACJ,GAQJ,SAASc,IAAQ,CAEjB,SAASC,EAAkBC,GACzB,GAAIA,EACF,OAAOA,EAAMC,cAAgBD,EAAKC,aAAa,OAAUD,EAAKE,EAElE,CAycA,IAAI/D,EAvcJ,SAAyBgE,GAEvB,OAAO,SAAkBC,EAAUC,EAAQC,GAKzC,GAJKA,IACHA,EAAU,CAAC,GAGS,iBAAXD,EACT,GAA0B,cAAtBD,EAASlC,UAAkD,SAAtBkC,EAASlC,UAA6C,SAAtBkC,EAASlC,SAAqB,CACrG,IAAIqC,EAAaF,GACjBA,EAAS9D,EAAII,cAAc,SACpBO,UAAYqD,CACrB,MACEF,EAASvD,EAAUuD,QAzBI,KA2BhBA,EAAOG,WAChBH,EAASA,EAAOI,mBAGlB,IAAIC,EAAaJ,EAAQI,YAAcX,EACnCY,EAAoBL,EAAQK,mBAAqBb,EACjDc,EAAcN,EAAQM,aAAed,EACrCe,EAAoBP,EAAQO,mBAAqBf,EACjDgB,EAAcR,EAAQQ,aAAehB,EACrCiB,EAAwBT,EAAQS,uBAAyBjB,EACzDkB,EAAkBV,EAAQU,iBAAmBlB,EAC7CmB,EAA4BX,EAAQW,2BAA6BnB,EACjEoB,EAAmBZ,EAAQY,kBAAoBpB,EAC/CqB,EAAWb,EAAQa,UAAY,SAASC,EAAQC,GAAQ,OAAOD,EAAOE,YAAYD,EAAQ,EAC1FE,GAAwC,IAAzBjB,EAAQiB,aAGvBC,EAAkBC,OAAOC,OAAO,MAChCC,EAAmB,GAEvB,SAASC,EAAgBC,GACvBF,EAAiBG,KAAKD,EACxB,CAEA,SAASE,EAAwB/B,EAAMgC,GACrC,GArDa,IAqDThC,EAAKQ,SAEP,IADA,IAAIZ,EAAWI,EAAKX,WACbO,GAAU,CAEf,IAAIiC,OAAMpF,EAENuF,IAAmBH,EAAMnB,EAAWd,IAGtCgC,EAAgBC,IAKhBb,EAAgBpB,GACZA,EAASP,YACX0C,EAAwBnC,EAAUoC,IAItCpC,EAAWA,EAASC,WACtB,CAEJ,CAUA,SAASoC,EAAWjC,EAAMpB,EAAYoD,IACA,IAAhCjB,EAAsBf,KAItBpB,GACFA,EAAWsD,YAAYlC,GAGzBgB,EAAgBhB,GAChB+B,EAAwB/B,EAAMgC,GAChC,CAiDA,SAASG,EAAgBC,GACvBxB,EAAYwB,GAGZ,IADA,IAAIxC,EAAWwC,EAAG/C,WACXO,GAAU,CACf,IAAIC,EAAcD,EAASC,YAEvBgC,EAAMnB,EAAWd,GACrB,GAAIiC,EAAK,CACP,IAAIQ,EAAkBb,EAAgBK,GAGlCQ,GAAmBzE,EAAiBgC,EAAUyC,IAChDzC,EAAShB,WAAW0D,aAAaD,EAAiBzC,GAClD2C,EAAQF,EAAiBzC,IAEzBuC,EAAgBvC,EAEpB,MAGEuC,EAAgBvC,GAGlBA,EAAWC,CACb,CACF,CAqBA,SAAS0C,EAAQ1E,EAAQC,EAAMyD,GAC7B,IAAIiB,EAAU9B,EAAW5C,GAQzB,GANI0E,UAGKhB,EAAgBgB,IAGpBjB,EAAc,CAEjB,IAAwC,IAApCV,EAAkBhD,EAAQC,GAC5B,OAQF,GAJAqC,EAAWtC,EAAQC,GAEnBgD,EAAYjD,IAEoC,IAA5CoD,EAA0BpD,EAAQC,GACpC,MAEJ,CAEwB,aAApBD,EAAOK,SAOb,SAAuBL,EAAQC,GAC7B,IAGI2E,EACAC,EAEAC,EACAC,EACAC,EARAC,EAAW5B,EAAiBrD,GAC5BkF,EAAiBjF,EAAKuB,WACtB2D,EAAmBnF,EAAOwB,WAS9B4D,EAAO,KAAOF,GAAgB,CAK5B,IAJAH,EAAgBG,EAAelD,YAC/B4C,EAAe/B,EAAWqC,IAGlBD,GAAYE,GAAkB,CAGpC,GAFAL,EAAkBK,EAAiBnD,YAE/BkD,EAAeG,YAAcH,EAAeG,WAAWF,GAAmB,CAC5ED,EAAiBH,EACjBI,EAAmBL,EACnB,SAASM,CACX,CAEAP,EAAiBhC,EAAWsC,GAE5B,IAAIG,EAAkBH,EAAiBxC,SAGnC4C,OAAe3G,EA6EnB,GA3EI0G,IAAoBJ,EAAevC,WAlQ9B,IAmQH2C,GAGEV,EAGEA,IAAiBC,KAIdG,EAAiBrB,EAAgBiB,IAChCE,IAAoBE,EAMtBO,GAAe,GASfvF,EAAOwF,aAAaR,EAAgBG,GAIhCN,EAGFd,EAAgBc,GAIhBT,EAAWe,EAAkBnF,GAAQ,GAGvCmF,EAAmBH,GAKrBO,GAAe,GAGVV,IAETU,GAAe,IAGjBA,GAAgC,IAAjBA,GAA0BxF,EAAiBoF,EAAkBD,KAM1ER,EAAQS,EAAkBD,IA5T1B,IA+TOI,GA9TJ,GA8TqCA,IAE1CC,GAAe,EAGXJ,EAAiBzD,YAAcwD,EAAexD,YAChDyD,EAAiBzD,UAAYwD,EAAexD,aAM9C6D,EAAc,CAGhBL,EAAiBH,EACjBI,EAAmBL,EACnB,SAASM,CACX,CAQIP,EAGFd,EAAgBc,GAIhBT,EAAWe,EAAkBnF,GAAQ,GAGvCmF,EAAmBL,CACrB,CAMA,GAAIF,IAAiBI,EAAiBrB,EAAgBiB,KAAkB7E,EAAiBiF,EAAgBE,GAEnGD,GAAW3B,EAAStD,EAAQgF,GAChCN,EAAQM,EAAgBE,OACnB,CACL,IAAIO,EAA0B3C,EAAkBoC,IAChB,IAA5BO,IACEA,IACFP,EAAiBO,GAGfP,EAAeQ,YACjBR,EAAiBA,EAAeQ,UAAU1F,EAAO2F,eAAiBjH,IAEpE4E,EAAStD,EAAQkF,GACjBZ,EAAgBY,GAEpB,CAEAA,EAAiBH,EACjBI,EAAmBL,CACrB,EAnNF,SAAuB9E,EAAQmF,EAAkBN,GAI/C,KAAOM,GAAkB,CACvB,IAAIL,EAAkBK,EAAiBnD,aAClC6C,EAAiBhC,EAAWsC,IAG/BpB,EAAgBc,GAIhBT,EAAWe,EAAkBnF,GAAQ,GAEvCmF,EAAmBL,CACrB,CACF,CAoMEc,CAAc5F,EAAQmF,EAAkBN,GAExC,IAAIgB,EAAmBhF,EAAkBb,EAAOK,UAC5CwF,GACFA,EAAiB7F,EAAQC,EAE7B,CA9KI6F,CAAc9F,EAAQC,GAEtBY,EAAkBS,SAAStB,EAAQC,EAEvC,EAhGA,SAAS8F,EAAU5D,GACjB,GAhIa,IAgITA,EAAKQ,UA/HgB,KA+HaR,EAAKQ,SAEzC,IADA,IAAIZ,EAAWI,EAAKX,WACbO,GAAU,CACf,IAAIiC,EAAMnB,EAAWd,GACjBiC,IACFL,EAAgBK,GAAOjC,GAIzBgE,EAAUhE,GAEVA,EAAWA,EAASC,WACtB,CAEJ,CAEA+D,CAAUxD,GA2PV,IA7gBqB7B,EAAMsF,EA6gBvBC,EAAc1D,EACd2D,EAAkBD,EAAYtD,SAC9BwD,EAAa3D,EAAOG,SAExB,IAAKe,EAGH,GAlZa,IAkZTwC,EAlZS,IAmZPC,EACGpG,EAAiBwC,EAAUC,KAC9BW,EAAgBZ,GAChB0D,EA/gBZ,SAAsBjG,EAAQC,GAE1B,IADA,IAAI8B,EAAW/B,EAAOwB,WACfO,GAAU,CACb,IAAIqE,EAAYrE,EAASC,YACzB/B,EAAKwD,YAAY1B,GACjBA,EAAWqE,CACf,CACA,OAAOnG,CACX,CAugB0BoG,CAAa9D,GAxhBd7B,EAwhBwC8B,EAAOnC,UAxhBzC2F,EAwhBmDxD,EAAOwD,eAvhB7DA,IAAiBvH,EAErCC,EAAI4H,gBAAgBN,EAActF,GADlChC,EAAII,cAAc4B,MA0hBhBuF,EAAczD,OAEX,GA1ZG,IA0ZC0D,GAzZE,IAyZ+BA,EAAoB,CAC9D,GAAIC,IAAeD,EAKjB,OAJID,EAAYvE,YAAcc,EAAOd,YACnCuE,EAAYvE,UAAYc,EAAOd,WAG1BuE,EAGPA,EAAczD,C,CAKpB,GAAIyD,IAAgBzD,EAGlBW,EAAgBZ,OACX,CACL,GAAIC,EAAO6C,YAAc7C,EAAO6C,WAAWY,GACzC,OAUF,GAPAvB,EAAQuB,EAAazD,EAAQkB,GAOzBI,EACF,IAAK,IAAIhC,EAAE,EAAGyE,EAAIzC,EAAiB0C,OAAQ1E,EAAEyE,EAAKzE,IAAK,CACrD,IAAI2E,EAAa9C,EAAgBG,EAAiBhC,IAC9C2E,GACFrC,EAAWqC,EAAYA,EAAW1F,YAAY,EAElD,CAEJ,CAcA,OAZK2C,GAAgBuC,IAAgB1D,GAAYA,EAASxB,aACpDkF,EAAYP,YACdO,EAAcA,EAAYP,UAAUnD,EAASoD,eAAiBjH,IAOhE6D,EAASxB,WAAW0D,aAAawB,EAAa1D,IAGzC0D,CACT,CACF,CAEeS,EAnvBf,SAAoBnE,EAAUC,GAC1B,IACImE,EACAC,EACAC,EACAC,EAJAC,EAAcvE,EAAOwE,WAQzB,GAXyB,KAWrBxE,EAAOG,UAXc,KAWyBJ,EAASI,SAA3D,CAKA,IAAK,IAAIb,EAAIiF,EAAYP,OAAS,EAAG1E,GAAK,EAAGA,IAEzC8E,GADAD,EAAOI,EAAYjF,IACHpB,KAChBmG,EAAmBF,EAAKX,aACxBc,EAAYH,EAAKtF,MAEbwF,GACAD,EAAWD,EAAKM,WAAaL,EACjBrE,EAAS2E,eAAeL,EAAkBD,KAEpCE,IACM,UAAhBH,EAAKQ,SACLP,EAAWD,EAAKjG,MAEpB6B,EAAS6E,eAAeP,EAAkBD,EAAUE,KAG5CvE,EAASH,aAAawE,KAEhBE,GACdvE,EAAS5B,aAAaiG,EAAUE,GAS5C,IAFA,IAAIO,EAAgB9E,EAASyE,WAEpBM,EAAID,EAAcb,OAAS,EAAGc,GAAK,EAAGA,IAE3CV,GADAD,EAAOU,EAAcC,IACL5G,MAChBmG,EAAmBF,EAAKX,eAGpBY,EAAWD,EAAKM,WAAaL,EAExBpE,EAAO+E,eAAeV,EAAkBD,IACzCrE,EAASiF,kBAAkBX,EAAkBD,IAG5CpE,EAAOvB,aAAa2F,IACrBrE,EAAS3B,gBAAgBgG,EA9CnC,CAkDN,IAyrBA,OAAOtI,CAEX","sources":["node_modules/morphdom/dist/morphdom-umd.js"],"sourcesContent":["(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n    typeof define === 'function' && define.amd ? define(factory) :\n    (global = global || self, global.morphdom = factory());\n}(this, function () { 'use strict';\n\n    var DOCUMENT_FRAGMENT_NODE = 11;\n\n    function morphAttrs(fromNode, toNode) {\n        var toNodeAttrs = toNode.attributes;\n        var attr;\n        var attrName;\n        var attrNamespaceURI;\n        var attrValue;\n        var fromValue;\n\n        // document-fragments dont have attributes so lets not do anything\n        if (toNode.nodeType === DOCUMENT_FRAGMENT_NODE || fromNode.nodeType === DOCUMENT_FRAGMENT_NODE) {\n          return;\n        }\n\n        // update attributes on original DOM element\n        for (var i = toNodeAttrs.length - 1; i >= 0; i--) {\n            attr = toNodeAttrs[i];\n            attrName = attr.name;\n            attrNamespaceURI = attr.namespaceURI;\n            attrValue = attr.value;\n\n            if (attrNamespaceURI) {\n                attrName = attr.localName || attrName;\n                fromValue = fromNode.getAttributeNS(attrNamespaceURI, attrName);\n\n                if (fromValue !== attrValue) {\n                    if (attr.prefix === 'xmlns'){\n                        attrName = attr.name; // It's not allowed to set an attribute with the XMLNS namespace without specifying the `xmlns` prefix\n                    }\n                    fromNode.setAttributeNS(attrNamespaceURI, attrName, attrValue);\n                }\n            } else {\n                fromValue = fromNode.getAttribute(attrName);\n\n                if (fromValue !== attrValue) {\n                    fromNode.setAttribute(attrName, attrValue);\n                }\n            }\n        }\n\n        // Remove any extra attributes found on the original DOM element that\n        // weren't found on the target element.\n        var fromNodeAttrs = fromNode.attributes;\n\n        for (var d = fromNodeAttrs.length - 1; d >= 0; d--) {\n            attr = fromNodeAttrs[d];\n            attrName = attr.name;\n            attrNamespaceURI = attr.namespaceURI;\n\n            if (attrNamespaceURI) {\n                attrName = attr.localName || attrName;\n\n                if (!toNode.hasAttributeNS(attrNamespaceURI, attrName)) {\n                    fromNode.removeAttributeNS(attrNamespaceURI, attrName);\n                }\n            } else {\n                if (!toNode.hasAttribute(attrName)) {\n                    fromNode.removeAttribute(attrName);\n                }\n            }\n        }\n    }\n\n    var range; // Create a range object for efficently rendering strings to elements.\n    var NS_XHTML = 'http://www.w3.org/1999/xhtml';\n\n    var doc = typeof document === 'undefined' ? undefined : document;\n    var HAS_TEMPLATE_SUPPORT = !!doc && 'content' in doc.createElement('template');\n    var HAS_RANGE_SUPPORT = !!doc && doc.createRange && 'createContextualFragment' in doc.createRange();\n\n    function createFragmentFromTemplate(str) {\n        var template = doc.createElement('template');\n        template.innerHTML = str;\n        return template.content.childNodes[0];\n    }\n\n    function createFragmentFromRange(str) {\n        if (!range) {\n            range = doc.createRange();\n            range.selectNode(doc.body);\n        }\n\n        var fragment = range.createContextualFragment(str);\n        return fragment.childNodes[0];\n    }\n\n    function createFragmentFromWrap(str) {\n        var fragment = doc.createElement('body');\n        fragment.innerHTML = str;\n        return fragment.childNodes[0];\n    }\n\n    /**\n     * This is about the same\n     * var html = new DOMParser().parseFromString(str, 'text/html');\n     * return html.body.firstChild;\n     *\n     * @method toElement\n     * @param {String} str\n     */\n    function toElement(str) {\n        str = str.trim();\n        if (HAS_TEMPLATE_SUPPORT) {\n          // avoid restrictions on content for things like `<tr><th>Hi</th></tr>` which\n          // createContextualFragment doesn't support\n          // <template> support not available in IE\n          return createFragmentFromTemplate(str);\n        } else if (HAS_RANGE_SUPPORT) {\n          return createFragmentFromRange(str);\n        }\n\n        return createFragmentFromWrap(str);\n    }\n\n    /**\n     * Returns true if two node's names are the same.\n     *\n     * NOTE: We don't bother checking `namespaceURI` because you will never find two HTML elements with the same\n     *       nodeName and different namespace URIs.\n     *\n     * @param {Element} a\n     * @param {Element} b The target element\n     * @return {boolean}\n     */\n    function compareNodeNames(fromEl, toEl) {\n        var fromNodeName = fromEl.nodeName;\n        var toNodeName = toEl.nodeName;\n        var fromCodeStart, toCodeStart;\n\n        if (fromNodeName === toNodeName) {\n            return true;\n        }\n\n        fromCodeStart = fromNodeName.charCodeAt(0);\n        toCodeStart = toNodeName.charCodeAt(0);\n\n        // If the target element is a virtual DOM node or SVG node then we may\n        // need to normalize the tag name before comparing. Normal HTML elements that are\n        // in the \"http://www.w3.org/1999/xhtml\"\n        // are converted to upper case\n        if (fromCodeStart <= 90 && toCodeStart >= 97) { // from is upper and to is lower\n            return fromNodeName === toNodeName.toUpperCase();\n        } else if (toCodeStart <= 90 && fromCodeStart >= 97) { // to is upper and from is lower\n            return toNodeName === fromNodeName.toUpperCase();\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * Create an element, optionally with a known namespace URI.\n     *\n     * @param {string} name the element name, e.g. 'div' or 'svg'\n     * @param {string} [namespaceURI] the element's namespace URI, i.e. the value of\n     * its `xmlns` attribute or its inferred namespace.\n     *\n     * @return {Element}\n     */\n    function createElementNS(name, namespaceURI) {\n        return !namespaceURI || namespaceURI === NS_XHTML ?\n            doc.createElement(name) :\n            doc.createElementNS(namespaceURI, name);\n    }\n\n    /**\n     * Copies the children of one DOM element to another DOM element\n     */\n    function moveChildren(fromEl, toEl) {\n        var curChild = fromEl.firstChild;\n        while (curChild) {\n            var nextChild = curChild.nextSibling;\n            toEl.appendChild(curChild);\n            curChild = nextChild;\n        }\n        return toEl;\n    }\n\n    function syncBooleanAttrProp(fromEl, toEl, name) {\n        if (fromEl[name] !== toEl[name]) {\n            fromEl[name] = toEl[name];\n            if (fromEl[name]) {\n                fromEl.setAttribute(name, '');\n            } else {\n                fromEl.removeAttribute(name);\n            }\n        }\n    }\n\n    var specialElHandlers = {\n        OPTION: function(fromEl, toEl) {\n            var parentNode = fromEl.parentNode;\n            if (parentNode) {\n                var parentName = parentNode.nodeName.toUpperCase();\n                if (parentName === 'OPTGROUP') {\n                    parentNode = parentNode.parentNode;\n                    parentName = parentNode && parentNode.nodeName.toUpperCase();\n                }\n                if (parentName === 'SELECT' && !parentNode.hasAttribute('multiple')) {\n                    if (fromEl.hasAttribute('selected') && !toEl.selected) {\n                        // Workaround for MS Edge bug where the 'selected' attribute can only be\n                        // removed if set to a non-empty value:\n                        // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/12087679/\n                        fromEl.setAttribute('selected', 'selected');\n                        fromEl.removeAttribute('selected');\n                    }\n                    // We have to reset select element's selectedIndex to -1, otherwise setting\n                    // fromEl.selected using the syncBooleanAttrProp below has no effect.\n                    // The correct selectedIndex will be set in the SELECT special handler below.\n                    parentNode.selectedIndex = -1;\n                }\n            }\n            syncBooleanAttrProp(fromEl, toEl, 'selected');\n        },\n        /**\n         * The \"value\" attribute is special for the <input> element since it sets\n         * the initial value. Changing the \"value\" attribute without changing the\n         * \"value\" property will have no effect since it is only used to the set the\n         * initial value.  Similar for the \"checked\" attribute, and \"disabled\".\n         */\n        INPUT: function(fromEl, toEl) {\n            syncBooleanAttrProp(fromEl, toEl, 'checked');\n            syncBooleanAttrProp(fromEl, toEl, 'disabled');\n\n            if (fromEl.value !== toEl.value) {\n                fromEl.value = toEl.value;\n            }\n\n            if (!toEl.hasAttribute('value')) {\n                fromEl.removeAttribute('value');\n            }\n        },\n\n        TEXTAREA: function(fromEl, toEl) {\n            var newValue = toEl.value;\n            if (fromEl.value !== newValue) {\n                fromEl.value = newValue;\n            }\n\n            var firstChild = fromEl.firstChild;\n            if (firstChild) {\n                // Needed for IE. Apparently IE sets the placeholder as the\n                // node value and vise versa. This ignores an empty update.\n                var oldValue = firstChild.nodeValue;\n\n                if (oldValue == newValue || (!newValue && oldValue == fromEl.placeholder)) {\n                    return;\n                }\n\n                firstChild.nodeValue = newValue;\n            }\n        },\n        SELECT: function(fromEl, toEl) {\n            if (!toEl.hasAttribute('multiple')) {\n                var selectedIndex = -1;\n                var i = 0;\n                // We have to loop through children of fromEl, not toEl since nodes can be moved\n                // from toEl to fromEl directly when morphing.\n                // At the time this special handler is invoked, all children have already been morphed\n                // and appended to / removed from fromEl, so using fromEl here is safe and correct.\n                var curChild = fromEl.firstChild;\n                var optgroup;\n                var nodeName;\n                while(curChild) {\n                    nodeName = curChild.nodeName && curChild.nodeName.toUpperCase();\n                    if (nodeName === 'OPTGROUP') {\n                        optgroup = curChild;\n                        curChild = optgroup.firstChild;\n                    } else {\n                        if (nodeName === 'OPTION') {\n                            if (curChild.hasAttribute('selected')) {\n                                selectedIndex = i;\n                                break;\n                            }\n                            i++;\n                        }\n                        curChild = curChild.nextSibling;\n                        if (!curChild && optgroup) {\n                            curChild = optgroup.nextSibling;\n                            optgroup = null;\n                        }\n                    }\n                }\n\n                fromEl.selectedIndex = selectedIndex;\n            }\n        }\n    };\n\n    var ELEMENT_NODE = 1;\n    var DOCUMENT_FRAGMENT_NODE$1 = 11;\n    var TEXT_NODE = 3;\n    var COMMENT_NODE = 8;\n\n    function noop() {}\n\n    function defaultGetNodeKey(node) {\n      if (node) {\n        return (node.getAttribute && node.getAttribute('id')) || node.id;\n      }\n    }\n\n    function morphdomFactory(morphAttrs) {\n\n      return function morphdom(fromNode, toNode, options) {\n        if (!options) {\n          options = {};\n        }\n\n        if (typeof toNode === 'string') {\n          if (fromNode.nodeName === '#document' || fromNode.nodeName === 'HTML' || fromNode.nodeName === 'BODY') {\n            var toNodeHtml = toNode;\n            toNode = doc.createElement('html');\n            toNode.innerHTML = toNodeHtml;\n          } else {\n            toNode = toElement(toNode);\n          }\n        } else if (toNode.nodeType === DOCUMENT_FRAGMENT_NODE$1) {\n          toNode = toNode.firstElementChild;\n        }\n\n        var getNodeKey = options.getNodeKey || defaultGetNodeKey;\n        var onBeforeNodeAdded = options.onBeforeNodeAdded || noop;\n        var onNodeAdded = options.onNodeAdded || noop;\n        var onBeforeElUpdated = options.onBeforeElUpdated || noop;\n        var onElUpdated = options.onElUpdated || noop;\n        var onBeforeNodeDiscarded = options.onBeforeNodeDiscarded || noop;\n        var onNodeDiscarded = options.onNodeDiscarded || noop;\n        var onBeforeElChildrenUpdated = options.onBeforeElChildrenUpdated || noop;\n        var skipFromChildren = options.skipFromChildren || noop;\n        var addChild = options.addChild || function(parent, child){ return parent.appendChild(child); };\n        var childrenOnly = options.childrenOnly === true;\n\n        // This object is used as a lookup to quickly find all keyed elements in the original DOM tree.\n        var fromNodesLookup = Object.create(null);\n        var keyedRemovalList = [];\n\n        function addKeyedRemoval(key) {\n          keyedRemovalList.push(key);\n        }\n\n        function walkDiscardedChildNodes(node, skipKeyedNodes) {\n          if (node.nodeType === ELEMENT_NODE) {\n            var curChild = node.firstChild;\n            while (curChild) {\n\n              var key = undefined;\n\n              if (skipKeyedNodes && (key = getNodeKey(curChild))) {\n                // If we are skipping keyed nodes then we add the key\n                // to a list so that it can be handled at the very end.\n                addKeyedRemoval(key);\n              } else {\n                // Only report the node as discarded if it is not keyed. We do this because\n                // at the end we loop through all keyed elements that were unmatched\n                // and then discard them in one final pass.\n                onNodeDiscarded(curChild);\n                if (curChild.firstChild) {\n                  walkDiscardedChildNodes(curChild, skipKeyedNodes);\n                }\n              }\n\n              curChild = curChild.nextSibling;\n            }\n          }\n        }\n\n        /**\n        * Removes a DOM node out of the original DOM\n        *\n        * @param  {Node} node The node to remove\n        * @param  {Node} parentNode The nodes parent\n        * @param  {Boolean} skipKeyedNodes If true then elements with keys will be skipped and not discarded.\n        * @return {undefined}\n        */\n        function removeNode(node, parentNode, skipKeyedNodes) {\n          if (onBeforeNodeDiscarded(node) === false) {\n            return;\n          }\n\n          if (parentNode) {\n            parentNode.removeChild(node);\n          }\n\n          onNodeDiscarded(node);\n          walkDiscardedChildNodes(node, skipKeyedNodes);\n        }\n\n        // // TreeWalker implementation is no faster, but keeping this around in case this changes in the future\n        // function indexTree(root) {\n        //     var treeWalker = document.createTreeWalker(\n        //         root,\n        //         NodeFilter.SHOW_ELEMENT);\n        //\n        //     var el;\n        //     while((el = treeWalker.nextNode())) {\n        //         var key = getNodeKey(el);\n        //         if (key) {\n        //             fromNodesLookup[key] = el;\n        //         }\n        //     }\n        // }\n\n        // // NodeIterator implementation is no faster, but keeping this around in case this changes in the future\n        //\n        // function indexTree(node) {\n        //     var nodeIterator = document.createNodeIterator(node, NodeFilter.SHOW_ELEMENT);\n        //     var el;\n        //     while((el = nodeIterator.nextNode())) {\n        //         var key = getNodeKey(el);\n        //         if (key) {\n        //             fromNodesLookup[key] = el;\n        //         }\n        //     }\n        // }\n\n        function indexTree(node) {\n          if (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE$1) {\n            var curChild = node.firstChild;\n            while (curChild) {\n              var key = getNodeKey(curChild);\n              if (key) {\n                fromNodesLookup[key] = curChild;\n              }\n\n              // Walk recursively\n              indexTree(curChild);\n\n              curChild = curChild.nextSibling;\n            }\n          }\n        }\n\n        indexTree(fromNode);\n\n        function handleNodeAdded(el) {\n          onNodeAdded(el);\n\n          var curChild = el.firstChild;\n          while (curChild) {\n            var nextSibling = curChild.nextSibling;\n\n            var key = getNodeKey(curChild);\n            if (key) {\n              var unmatchedFromEl = fromNodesLookup[key];\n              // if we find a duplicate #id node in cache, replace `el` with cache value\n              // and morph it to the child node.\n              if (unmatchedFromEl && compareNodeNames(curChild, unmatchedFromEl)) {\n                curChild.parentNode.replaceChild(unmatchedFromEl, curChild);\n                morphEl(unmatchedFromEl, curChild);\n              } else {\n                handleNodeAdded(curChild);\n              }\n            } else {\n              // recursively call for curChild and it's children to see if we find something in\n              // fromNodesLookup\n              handleNodeAdded(curChild);\n            }\n\n            curChild = nextSibling;\n          }\n        }\n\n        function cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey) {\n          // We have processed all of the \"to nodes\". If curFromNodeChild is\n          // non-null then we still have some from nodes left over that need\n          // to be removed\n          while (curFromNodeChild) {\n            var fromNextSibling = curFromNodeChild.nextSibling;\n            if ((curFromNodeKey = getNodeKey(curFromNodeChild))) {\n              // Since the node is keyed it might be matched up later so we defer\n              // the actual removal to later\n              addKeyedRemoval(curFromNodeKey);\n            } else {\n              // NOTE: we skip nested keyed nodes from being removed since there is\n              //       still a chance they will be matched up later\n              removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n            }\n            curFromNodeChild = fromNextSibling;\n          }\n        }\n\n        function morphEl(fromEl, toEl, childrenOnly) {\n          var toElKey = getNodeKey(toEl);\n\n          if (toElKey) {\n            // If an element with an ID is being morphed then it will be in the final\n            // DOM so clear it out of the saved elements collection\n            delete fromNodesLookup[toElKey];\n          }\n\n          if (!childrenOnly) {\n            // optional\n            if (onBeforeElUpdated(fromEl, toEl) === false) {\n              return;\n            }\n\n            // update attributes on original DOM element first\n            morphAttrs(fromEl, toEl);\n            // optional\n            onElUpdated(fromEl);\n\n            if (onBeforeElChildrenUpdated(fromEl, toEl) === false) {\n              return;\n            }\n          }\n\n          if (fromEl.nodeName !== 'TEXTAREA') {\n            morphChildren(fromEl, toEl);\n          } else {\n            specialElHandlers.TEXTAREA(fromEl, toEl);\n          }\n        }\n\n        function morphChildren(fromEl, toEl) {\n          var skipFrom = skipFromChildren(fromEl);\n          var curToNodeChild = toEl.firstChild;\n          var curFromNodeChild = fromEl.firstChild;\n          var curToNodeKey;\n          var curFromNodeKey;\n\n          var fromNextSibling;\n          var toNextSibling;\n          var matchingFromEl;\n\n          // walk the children\n          outer: while (curToNodeChild) {\n            toNextSibling = curToNodeChild.nextSibling;\n            curToNodeKey = getNodeKey(curToNodeChild);\n\n            // walk the fromNode children all the way through\n            while (!skipFrom && curFromNodeChild) {\n              fromNextSibling = curFromNodeChild.nextSibling;\n\n              if (curToNodeChild.isSameNode && curToNodeChild.isSameNode(curFromNodeChild)) {\n                curToNodeChild = toNextSibling;\n                curFromNodeChild = fromNextSibling;\n                continue outer;\n              }\n\n              curFromNodeKey = getNodeKey(curFromNodeChild);\n\n              var curFromNodeType = curFromNodeChild.nodeType;\n\n              // this means if the curFromNodeChild doesnt have a match with the curToNodeChild\n              var isCompatible = undefined;\n\n              if (curFromNodeType === curToNodeChild.nodeType) {\n                if (curFromNodeType === ELEMENT_NODE) {\n                  // Both nodes being compared are Element nodes\n\n                  if (curToNodeKey) {\n                    // The target node has a key so we want to match it up with the correct element\n                    // in the original DOM tree\n                    if (curToNodeKey !== curFromNodeKey) {\n                      // The current element in the original DOM tree does not have a matching key so\n                      // let's check our lookup to see if there is a matching element in the original\n                      // DOM tree\n                      if ((matchingFromEl = fromNodesLookup[curToNodeKey])) {\n                        if (fromNextSibling === matchingFromEl) {\n                          // Special case for single element removals. To avoid removing the original\n                          // DOM node out of the tree (since that can break CSS transitions, etc.),\n                          // we will instead discard the current node and wait until the next\n                          // iteration to properly match up the keyed target element with its matching\n                          // element in the original tree\n                          isCompatible = false;\n                        } else {\n                          // We found a matching keyed element somewhere in the original DOM tree.\n                          // Let's move the original DOM node into the current position and morph\n                          // it.\n\n                          // NOTE: We use insertBefore instead of replaceChild because we want to go through\n                          // the `removeNode()` function for the node that is being discarded so that\n                          // all lifecycle hooks are correctly invoked\n                          fromEl.insertBefore(matchingFromEl, curFromNodeChild);\n\n                          // fromNextSibling = curFromNodeChild.nextSibling;\n\n                          if (curFromNodeKey) {\n                            // Since the node is keyed it might be matched up later so we defer\n                            // the actual removal to later\n                            addKeyedRemoval(curFromNodeKey);\n                          } else {\n                            // NOTE: we skip nested keyed nodes from being removed since there is\n                            //       still a chance they will be matched up later\n                            removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n                          }\n\n                          curFromNodeChild = matchingFromEl;\n                        }\n                      } else {\n                        // The nodes are not compatible since the \"to\" node has a key and there\n                        // is no matching keyed node in the source tree\n                        isCompatible = false;\n                      }\n                    }\n                  } else if (curFromNodeKey) {\n                    // The original has a key\n                    isCompatible = false;\n                  }\n\n                  isCompatible = isCompatible !== false && compareNodeNames(curFromNodeChild, curToNodeChild);\n                  if (isCompatible) {\n                    // We found compatible DOM elements so transform\n                    // the current \"from\" node to match the current\n                    // target DOM node.\n                    // MORPH\n                    morphEl(curFromNodeChild, curToNodeChild);\n                  }\n\n                } else if (curFromNodeType === TEXT_NODE || curFromNodeType == COMMENT_NODE) {\n                  // Both nodes being compared are Text or Comment nodes\n                  isCompatible = true;\n                  // Simply update nodeValue on the original node to\n                  // change the text value\n                  if (curFromNodeChild.nodeValue !== curToNodeChild.nodeValue) {\n                    curFromNodeChild.nodeValue = curToNodeChild.nodeValue;\n                  }\n\n                }\n              }\n\n              if (isCompatible) {\n                // Advance both the \"to\" child and the \"from\" child since we found a match\n                // Nothing else to do as we already recursively called morphChildren above\n                curToNodeChild = toNextSibling;\n                curFromNodeChild = fromNextSibling;\n                continue outer;\n              }\n\n              // No compatible match so remove the old node from the DOM and continue trying to find a\n              // match in the original DOM. However, we only do this if the from node is not keyed\n              // since it is possible that a keyed node might match up with a node somewhere else in the\n              // target tree and we don't want to discard it just yet since it still might find a\n              // home in the final DOM tree. After everything is done we will remove any keyed nodes\n              // that didn't find a home\n              if (curFromNodeKey) {\n                // Since the node is keyed it might be matched up later so we defer\n                // the actual removal to later\n                addKeyedRemoval(curFromNodeKey);\n              } else {\n                // NOTE: we skip nested keyed nodes from being removed since there is\n                //       still a chance they will be matched up later\n                removeNode(curFromNodeChild, fromEl, true /* skip keyed nodes */);\n              }\n\n              curFromNodeChild = fromNextSibling;\n            } // END: while(curFromNodeChild) {}\n\n            // If we got this far then we did not find a candidate match for\n            // our \"to node\" and we exhausted all of the children \"from\"\n            // nodes. Therefore, we will just append the current \"to\" node\n            // to the end\n            if (curToNodeKey && (matchingFromEl = fromNodesLookup[curToNodeKey]) && compareNodeNames(matchingFromEl, curToNodeChild)) {\n              // MORPH\n              if(!skipFrom){ addChild(fromEl, matchingFromEl); }\n              morphEl(matchingFromEl, curToNodeChild);\n            } else {\n              var onBeforeNodeAddedResult = onBeforeNodeAdded(curToNodeChild);\n              if (onBeforeNodeAddedResult !== false) {\n                if (onBeforeNodeAddedResult) {\n                  curToNodeChild = onBeforeNodeAddedResult;\n                }\n\n                if (curToNodeChild.actualize) {\n                  curToNodeChild = curToNodeChild.actualize(fromEl.ownerDocument || doc);\n                }\n                addChild(fromEl, curToNodeChild);\n                handleNodeAdded(curToNodeChild);\n              }\n            }\n\n            curToNodeChild = toNextSibling;\n            curFromNodeChild = fromNextSibling;\n          }\n\n          cleanupFromEl(fromEl, curFromNodeChild, curFromNodeKey);\n\n          var specialElHandler = specialElHandlers[fromEl.nodeName];\n          if (specialElHandler) {\n            specialElHandler(fromEl, toEl);\n          }\n        } // END: morphChildren(...)\n\n        var morphedNode = fromNode;\n        var morphedNodeType = morphedNode.nodeType;\n        var toNodeType = toNode.nodeType;\n\n        if (!childrenOnly) {\n          // Handle the case where we are given two DOM nodes that are not\n          // compatible (e.g. <div> --> <span> or <div> --> TEXT)\n          if (morphedNodeType === ELEMENT_NODE) {\n            if (toNodeType === ELEMENT_NODE) {\n              if (!compareNodeNames(fromNode, toNode)) {\n                onNodeDiscarded(fromNode);\n                morphedNode = moveChildren(fromNode, createElementNS(toNode.nodeName, toNode.namespaceURI));\n              }\n            } else {\n              // Going from an element node to a text node\n              morphedNode = toNode;\n            }\n          } else if (morphedNodeType === TEXT_NODE || morphedNodeType === COMMENT_NODE) { // Text or comment node\n            if (toNodeType === morphedNodeType) {\n              if (morphedNode.nodeValue !== toNode.nodeValue) {\n                morphedNode.nodeValue = toNode.nodeValue;\n              }\n\n              return morphedNode;\n            } else {\n              // Text node to something else\n              morphedNode = toNode;\n            }\n          }\n        }\n\n        if (morphedNode === toNode) {\n          // The \"to node\" was not compatible with the \"from node\" so we had to\n          // toss out the \"from node\" and use the \"to node\"\n          onNodeDiscarded(fromNode);\n        } else {\n          if (toNode.isSameNode && toNode.isSameNode(morphedNode)) {\n            return;\n          }\n\n          morphEl(morphedNode, toNode, childrenOnly);\n\n          // We now need to loop over any keyed nodes that might need to be\n          // removed. We only do the removal if we know that the keyed node\n          // never found a match. When a keyed node is matched up we remove\n          // it out of fromNodesLookup and we use fromNodesLookup to determine\n          // if a keyed node has been matched up or not\n          if (keyedRemovalList) {\n            for (var i=0, len=keyedRemovalList.length; i<len; i++) {\n              var elToRemove = fromNodesLookup[keyedRemovalList[i]];\n              if (elToRemove) {\n                removeNode(elToRemove, elToRemove.parentNode, false);\n              }\n            }\n          }\n        }\n\n        if (!childrenOnly && morphedNode !== fromNode && fromNode.parentNode) {\n          if (morphedNode.actualize) {\n            morphedNode = morphedNode.actualize(fromNode.ownerDocument || doc);\n          }\n          // If we had to swap out the from node with a new node because the old\n          // node was not compatible with the target node then we need to\n          // replace the old DOM node in the original DOM tree. This is only\n          // possible if the original DOM node was part of a DOM tree which\n          // we know is the case if it has a parent node.\n          fromNode.parentNode.replaceChild(morphedNode, fromNode);\n        }\n\n        return morphedNode;\n      };\n    }\n\n    var morphdom = morphdomFactory(morphAttrs);\n\n    return morphdom;\n\n}));\n"],"names":["global","factory","exports","module","define","amd","self","morphdom","this","range","NS_XHTML","doc","document","undefined","HAS_TEMPLATE_SUPPORT","createElement","HAS_RANGE_SUPPORT","createRange","toElement","str","trim","template","innerHTML","content","childNodes","createFragmentFromTemplate","selectNode","body","createContextualFragment","createFragmentFromRange","fragment","createFragmentFromWrap","compareNodeNames","fromEl","toEl","fromCodeStart","toCodeStart","fromNodeName","nodeName","toNodeName","charCodeAt","toUpperCase","syncBooleanAttrProp","name","setAttribute","removeAttribute","specialElHandlers","OPTION","parentNode","parentName","hasAttribute","selected","selectedIndex","INPUT","value","TEXTAREA","newValue","firstChild","oldValue","nodeValue","placeholder","SELECT","optgroup","i","curChild","nextSibling","noop","defaultGetNodeKey","node","getAttribute","id","morphAttrs","fromNode","toNode","options","toNodeHtml","nodeType","firstElementChild","getNodeKey","onBeforeNodeAdded","onNodeAdded","onBeforeElUpdated","onElUpdated","onBeforeNodeDiscarded","onNodeDiscarded","onBeforeElChildrenUpdated","skipFromChildren","addChild","parent","child","appendChild","childrenOnly","fromNodesLookup","Object","create","keyedRemovalList","addKeyedRemoval","key","push","walkDiscardedChildNodes","skipKeyedNodes","removeNode","removeChild","handleNodeAdded","el","unmatchedFromEl","replaceChild","morphEl","toElKey","curToNodeKey","curFromNodeKey","fromNextSibling","toNextSibling","matchingFromEl","skipFrom","curToNodeChild","curFromNodeChild","outer","isSameNode","curFromNodeType","isCompatible","insertBefore","onBeforeNodeAddedResult","actualize","ownerDocument","cleanupFromEl","specialElHandler","morphChildren","indexTree","namespaceURI","morphedNode","morphedNodeType","toNodeType","nextChild","moveChildren","createElementNS","len","length","elToRemove","morphdomFactory","attr","attrName","attrNamespaceURI","attrValue","toNodeAttrs","attributes","localName","getAttributeNS","prefix","setAttributeNS","fromNodeAttrs","d","hasAttributeNS","removeAttributeNS"],"version":3,"file":"index.0c5df85e.js.map"}