{"version":3,"sources":["webpack:///./node_modules/inferno/dist/index.esm.js"],"names":["isArray","Array","isStringOrNumber","o","type","isNullOrUndef","isInvalid","isFunction","isString","isNumber","isNull","isUndefined","combineFrom","first","second","out","key","key$1","isLinkEventObject","EMPTY_OBJ","Fragment","normalizeEventName","name","substr","toLowerCase","appendChild","parentDOM","dom","insertOrAppend","newNode","nextNode","insertBefore","documentCreateElement","tag","isSVG","document","createElementNS","createElement","replaceChild","newDom","lastDom","removeChild","childNode","callAll","arrayFn","i","length","findChildVNode","vNode","startEdge","flags","children","$LI","childFlags","findDOMfromVNode","removeVNodeDOM","len","moveVNodeDOM","createDerivedState","instance","nextProps","state","constructor","getDerivedStateFromProps","renderCheck","v","options","componentComparator","createVNode","renderComplete","setTextContent","textContent","isLastValueSameLinkEvent","lastValue","nextValue","event","data","mergeUnsetProperties","to","from","propName","safeCall1","method","arg1","keyPrefix","V","className","props","ref","this","childFlag","normalizeChildren","mergeDefaultHooks","defaultHooks","render","mergeDefaultProps","defaultProps","resolveComponentFlags","prototype","createComponentVNode","createTextVNode","text","createFragment","fragment","createVoidVNode","normalizeProps","undefined","cloneFragment","vNodeToClone","oldChildren","directClone","map","propsToClone","createPortal","container","normalizedRoot","normalizeRoot","_normalizeVNodes","nodes","result","index","currentKey","n","newKey","oldKey","isPrefixedKey","substring","push","getFlagsForElementVnode","newChildren","newChildFlags","slice","needsCloning","isNullKey","isPrefixed","input","xlinkNS","xmlNS","namespaces","getDelegatedEventObject","onClick","onDblClick","onFocusIn","onFocusOut","onKeyDown","onKeyPress","onKeyUp","onMouseDown","onMouseMove","onMouseUp","onTouchEnd","onTouchMove","onTouchStart","attachedEventCounts","attachedEvents","syntheticEvents","updateOrAddSyntheticEvent","eventsObject","$EV","attachEventToDocument","unmountSyntheticEvent","removeEventListener","handleSyntheticEvent","lastEvent","nextEvent","getTargetNode","composedPath","target","dispatchEvents","isClick","eventData","disabled","currentEvent","cancelBubble","parentNode","stopPropagation","immediatePropagationStopped","stopImmediatePropagation","isDefaultPrevented","defaultPrevented","isPropagationStopped","extendEventProperties","Object","defineProperty","configurable","get","rootClickEvent","button","rootEvent","attachedEvent","addEventListener","isSameInnerHTML","innerHTML","tempdom","triggerEventListener","methodName","e","listener","nativeListenerName","createWrappedFunction","applyValue","fnMethod","$V","newVNode","newProps","enumerable","value","writable","attachEvent","eventName","handler","previousKey","previousArgs","wrapped","isCheckedType","onTextInputChange","applyValueInput","wrappedOnChange","emptywrapper","inputEvents","nextPropsOrEmpty","checked","multiple","defaultValue","hasValue","setAttribute","updateChildOptions","updateChildOption","indexOf","selected","onSelectChange","applyValueSelect","selectEvents","mounting","multiplePropInBoolean","Boolean","selectedIndex","p","onTextareaInputChange","applyValueTextArea","wrappedOnChange$1","textAreaEvents","onChange","domValue","processElement","isControlled","addFormElementEventHandlers","isControlledFormElement","createRef","current","unmountRef","mountRef","lifecycle","remove","unmount","keys","unmountAllChildren","componentWillUnmount","$UN","onComponentWillUnmount","clearDOM","removeAllChildren","wrapLinkEvent","ev","patchEvent","patchStyle","lastAttrValue","nextAttrValue","removeAttribute","style","domStyle","cssText","setProperty","removeProperty","patchDangerInnerHTML","lastVNode","lastHtml","__html","nextHtml","patchProp","prop","hasControlledValue","autofocus","charCodeAt","setAttributeNS","mountProps","isFormElement","renderNewInput","context","nextInput","childContext","getChildContext","$CX","createClassComponentInstance","Component","usesNewAPI","$N","getSnapshotBeforeUpdate","$SVG","$L","$BS","componentWillMount","$BR","pending","$PS","renderFunctionalComponent","mount","mountElement","mountClassComponent","mountFunctionalComponent","mountFunctionalComponentCallbacks","mountText","mountFragment","mountPortal","placeHolderVNode","mountArrayChildren","createTextNode","childrenIsSVG","child","mountClassComponentCallbacks","createClassMountCallback","componentDidMount","createOnMountCallback","onComponentDidMount","onComponentWillMount","replaceWithNewNode","nextVNode","patch","nextFlags","patchElement","patchClassComponent","patchFunctionalComponent","patchText","patchFragment","patchPortal","patchSingleTextChild","lastChildren","nextChildren","firstChild","nodeValue","patchContentEditableChildren","lastChildFlags","nextChildFlags","nextIsSingle","lastLen","nextSibling","patchChildren","lastContainer","nextContainer","node","lastProps","lastPropsOrEmpty","prop$1","nextClassName","nextRef","lastRef","replaceOneVNodeWithMultipleVNodes","parentVNode","lastLength","nextLength","patchKeyedChildren","patchNonKeyedChildren","createDidUpdate","lastState","snapshot","componentDidUpdate","updateClassComponent","nextState","force","hasSCU","shouldComponentUpdate","componentWillUpdate","componentWillReceiveProps","shouldUpdate","nextHooksDefined","lastInput","onComponentShouldUpdate","onComponentWillUpdate","onComponentDidUpdate","nextText","lastChildrenLength","nextChildrenLength","nextChild","lastChild","commonLength","a","b","aLength","bLength","outerEdge","nextPos","aEnd","bEnd","j","aNode","bNode","outer","patchKeyedChildrenComplex","aStart","bStart","aLeft","bLeft","sources","Int32Array","canRemoveWholeContent","moved","pos","patched","keyIndex","seq","lis_algorithm","maxLen","arr","arrI","k","u","c","hasDocumentAvailable","__render","callback","rootInput","window","Node","QUEUE","nextTick","Promise","resolve","then","bind","setTimeout","microTaskPending","queueStateChanges","component","newState","stateKey","applyState","call","$F","rerender","QU","$QU","callSetStateCallbacks","queue","shift","pendingState","forceUpdate","setState","_nextProps","_nextState","_nextContext"],"mappings":"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","file":"js/npm.inferno.e6061d00.js","sourcesContent":["var isArray = Array.isArray;\nfunction isStringOrNumber(o) {\n    var type = typeof o;\n    return type === 'string' || type === 'number';\n}\nfunction isNullOrUndef(o) {\n    return o === void 0 || o === null;\n}\nfunction isInvalid(o) {\n    return o === null || o === false || o === true || o === void 0;\n}\nfunction isFunction(o) {\n    return typeof o === 'function';\n}\nfunction isString(o) {\n    return typeof o === 'string';\n}\nfunction isNumber(o) {\n    return typeof o === 'number';\n}\nfunction isNull(o) {\n    return o === null;\n}\nfunction isUndefined(o) {\n    return o === void 0;\n}\nfunction combineFrom(first, second) {\n    var out = {};\n    if (first) {\n        for (var key in first) {\n            out[key] = first[key];\n        }\n    }\n    if (second) {\n        for (var key$1 in second) {\n            out[key$1] = second[key$1];\n        }\n    }\n    return out;\n}\n\n/**\n * Links given data to event as first parameter\n * @param {*} data data to be linked, it will be available in function as first parameter\n * @param {Function} event Function to be called when event occurs\n * @returns {{data: *, event: Function}}\n */\nfunction linkEvent(data, event) {\n    if (isFunction(event)) {\n        return { data: data, event: event };\n    }\n    return null; // Return null when event is invalid, to avoid creating unnecessary event handlers\n}\n// object.event should always be function, otherwise its badly created object.\nfunction isLinkEventObject(o) {\n    return !isNull(o) && typeof o === 'object';\n}\n\n// We need EMPTY_OBJ defined in one place.\n// Its used for comparison so we cant inline it into shared\nvar EMPTY_OBJ = {};\nvar Fragment = '$F';\nfunction normalizeEventName(name) {\n    return name.substr(2).toLowerCase();\n}\nfunction appendChild(parentDOM, dom) {\n    parentDOM.appendChild(dom);\n}\nfunction insertOrAppend(parentDOM, newNode, nextNode) {\n    if (isNull(nextNode)) {\n        appendChild(parentDOM, newNode);\n    }\n    else {\n        parentDOM.insertBefore(newNode, nextNode);\n    }\n}\nfunction documentCreateElement(tag, isSVG) {\n    if (isSVG) {\n        return document.createElementNS('http://www.w3.org/2000/svg', tag);\n    }\n    return document.createElement(tag);\n}\nfunction replaceChild(parentDOM, newDom, lastDom) {\n    parentDOM.replaceChild(newDom, lastDom);\n}\nfunction removeChild(parentDOM, childNode) {\n    parentDOM.removeChild(childNode);\n}\nfunction callAll(arrayFn) {\n    for (var i = 0; i < arrayFn.length; i++) {\n        arrayFn[i]();\n    }\n}\nfunction findChildVNode(vNode, startEdge, flags) {\n    var children = vNode.children;\n    if (flags & 4 /* ComponentClass */) {\n        return children.$LI;\n    }\n    if (flags & 8192 /* Fragment */) {\n        return vNode.childFlags === 2 /* HasVNodeChildren */ ? children : children[startEdge ? 0 : children.length - 1];\n    }\n    return children;\n}\nfunction findDOMfromVNode(vNode, startEdge) {\n    var flags;\n    while (vNode) {\n        flags = vNode.flags;\n        if (flags & 2033 /* DOMRef */) {\n            return vNode.dom;\n        }\n        vNode = findChildVNode(vNode, startEdge, flags);\n    }\n    return null;\n}\nfunction removeVNodeDOM(vNode, parentDOM) {\n    do {\n        var flags = vNode.flags;\n        if (flags & 2033 /* DOMRef */) {\n            removeChild(parentDOM, vNode.dom);\n            return;\n        }\n        var children = vNode.children;\n        if (flags & 4 /* ComponentClass */) {\n            vNode = children.$LI;\n        }\n        if (flags & 8 /* ComponentFunction */) {\n            vNode = children;\n        }\n        if (flags & 8192 /* Fragment */) {\n            if (vNode.childFlags === 2 /* HasVNodeChildren */) {\n                vNode = children;\n            }\n            else {\n                for (var i = 0, len = children.length; i < len; ++i) {\n                    removeVNodeDOM(children[i], parentDOM);\n                }\n                return;\n            }\n        }\n    } while (vNode);\n}\nfunction moveVNodeDOM(vNode, parentDOM, nextNode) {\n    do {\n        var flags = vNode.flags;\n        if (flags & 2033 /* DOMRef */) {\n            insertOrAppend(parentDOM, vNode.dom, nextNode);\n            return;\n        }\n        var children = vNode.children;\n        if (flags & 4 /* ComponentClass */) {\n            vNode = children.$LI;\n        }\n        if (flags & 8 /* ComponentFunction */) {\n            vNode = children;\n        }\n        if (flags & 8192 /* Fragment */) {\n            if (vNode.childFlags === 2 /* HasVNodeChildren */) {\n                vNode = children;\n            }\n            else {\n                for (var i = 0, len = children.length; i < len; ++i) {\n                    moveVNodeDOM(children[i], parentDOM, nextNode);\n                }\n                return;\n            }\n        }\n    } while (vNode);\n}\nfunction createDerivedState(instance, nextProps, state) {\n    if (instance.constructor.getDerivedStateFromProps) {\n        return combineFrom(state, instance.constructor.getDerivedStateFromProps(nextProps, state));\n    }\n    return state;\n}\nvar renderCheck = {\n    v: false\n};\nvar options = {\n    componentComparator: null,\n    createVNode: null,\n    renderComplete: null\n};\nfunction setTextContent(dom, children) {\n    dom.textContent = children;\n}\n// Calling this function assumes, nextValue is linkEvent\nfunction isLastValueSameLinkEvent(lastValue, nextValue) {\n    return (isLinkEventObject(lastValue) &&\n        lastValue.event === nextValue.event &&\n        lastValue.data === nextValue.data);\n}\nfunction mergeUnsetProperties(to, from) {\n    for (var propName in from) {\n        if (isUndefined(to[propName])) {\n            to[propName] = from[propName];\n        }\n    }\n    return to;\n}\nfunction safeCall1(method, arg1) {\n    return !!isFunction(method) && (method(arg1), true);\n}\n\nvar keyPrefix = '$';\nfunction V(childFlags, children, className, flags, key, props, ref, type) {\n    this.childFlags = childFlags;\n    this.children = children;\n    this.className = className;\n    this.dom = null;\n    this.flags = flags;\n    this.key = key === void 0 ? null : key;\n    this.props = props === void 0 ? null : props;\n    this.ref = ref === void 0 ? null : ref;\n    this.type = type;\n}\nfunction createVNode(flags, type, className, children, childFlags, props, key, ref) {\n    var childFlag = childFlags === void 0 ? 1 /* HasInvalidChildren */ : childFlags;\n    var vNode = new V(childFlag, children, className, flags, key, props, ref, type);\n    if (options.createVNode) {\n        options.createVNode(vNode);\n    }\n    if (childFlag === 0 /* UnknownChildren */) {\n        normalizeChildren(vNode, vNode.children);\n    }\n    return vNode;\n}\nfunction mergeDefaultHooks(flags, type, ref) {\n    if (flags & 4 /* ComponentClass */) {\n        return ref;\n    }\n    var defaultHooks = (flags & 32768 /* ForwardRef */ ? type.render : type).defaultHooks;\n    if (isNullOrUndef(defaultHooks)) {\n        return ref;\n    }\n    if (isNullOrUndef(ref)) {\n        return defaultHooks;\n    }\n    return mergeUnsetProperties(ref, defaultHooks);\n}\nfunction mergeDefaultProps(flags, type, props) {\n    // set default props\n    var defaultProps = (flags & 32768 /* ForwardRef */ ? type.render : type).defaultProps;\n    if (isNullOrUndef(defaultProps)) {\n        return props;\n    }\n    if (isNullOrUndef(props)) {\n        return combineFrom(defaultProps, null);\n    }\n    return mergeUnsetProperties(props, defaultProps);\n}\nfunction resolveComponentFlags(flags, type) {\n    if (flags & 12 /* ComponentKnown */) {\n        return flags;\n    }\n    if (type.prototype && type.prototype.render) {\n        return 4 /* ComponentClass */;\n    }\n    if (type.render) {\n        return 32776 /* ForwardRefComponent */;\n    }\n    return 8 /* ComponentFunction */;\n}\nfunction createComponentVNode(flags, type, props, key, ref) {\n    flags = resolveComponentFlags(flags, type);\n    var vNode = new V(1 /* HasInvalidChildren */, null, null, flags, key, mergeDefaultProps(flags, type, props), mergeDefaultHooks(flags, type, ref), type);\n    if (options.createVNode) {\n        options.createVNode(vNode);\n    }\n    return vNode;\n}\nfunction createTextVNode(text, key) {\n    return new V(1 /* HasInvalidChildren */, isNullOrUndef(text) || text === true || text === false ? '' : text, null, 16 /* Text */, key, null, null, null);\n}\nfunction createFragment(children, childFlags, key) {\n    var fragment = createVNode(8192 /* Fragment */, 8192 /* Fragment */, null, children, childFlags, null, key, null);\n    switch (fragment.childFlags) {\n        case 1 /* HasInvalidChildren */:\n            fragment.children = createVoidVNode();\n            fragment.childFlags = 2 /* HasVNodeChildren */;\n            break;\n        case 16 /* HasTextChildren */:\n            fragment.children = [createTextVNode(children)];\n            fragment.childFlags = 4 /* HasNonKeyedChildren */;\n            break;\n    }\n    return fragment;\n}\nfunction normalizeProps(vNode) {\n    var props = vNode.props;\n    if (props) {\n        var flags = vNode.flags;\n        if (flags & 481 /* Element */) {\n            if (props.children !== void 0 && isNullOrUndef(vNode.children)) {\n                normalizeChildren(vNode, props.children);\n            }\n            if (props.className !== void 0) {\n                if (isNullOrUndef(vNode.className)) {\n                    vNode.className = props.className || null;\n                }\n                props.className = undefined;\n            }\n        }\n        if (props.key !== void 0) {\n            vNode.key = props.key;\n            props.key = undefined;\n        }\n        if (props.ref !== void 0) {\n            if (flags & 8 /* ComponentFunction */) {\n                vNode.ref = combineFrom(vNode.ref, props.ref);\n            }\n            else {\n                vNode.ref = props.ref;\n            }\n            props.ref = undefined;\n        }\n    }\n    return vNode;\n}\n/*\n * Fragment is different than normal vNode,\n * because when it needs to be cloned we need to clone its children too\n * But not normalize, because otherwise those possibly get KEY and re-mount\n */\nfunction cloneFragment(vNodeToClone) {\n    var oldChildren = vNodeToClone.children;\n    var childFlags = vNodeToClone.childFlags;\n    return createFragment(childFlags === 2 /* HasVNodeChildren */ ? directClone(oldChildren) : oldChildren.map(directClone), childFlags, vNodeToClone.key);\n}\nfunction directClone(vNodeToClone) {\n    var flags = vNodeToClone.flags & -16385 /* ClearInUse */;\n    var props = vNodeToClone.props;\n    if (flags & 14 /* Component */) {\n        if (!isNull(props)) {\n            var propsToClone = props;\n            props = {};\n            for (var key in propsToClone) {\n                props[key] = propsToClone[key];\n            }\n        }\n    }\n    if ((flags & 8192 /* Fragment */) === 0) {\n        return new V(vNodeToClone.childFlags, vNodeToClone.children, vNodeToClone.className, flags, vNodeToClone.key, props, vNodeToClone.ref, vNodeToClone.type);\n    }\n    return cloneFragment(vNodeToClone);\n}\nfunction createVoidVNode() {\n    return createTextVNode('', null);\n}\nfunction createPortal(children, container) {\n    var normalizedRoot = normalizeRoot(children);\n    return createVNode(1024 /* Portal */, 1024 /* Portal */, null, normalizedRoot, 0 /* UnknownChildren */, null, normalizedRoot.key, container);\n}\nfunction _normalizeVNodes(nodes, result, index, currentKey) {\n    for (var len = nodes.length; index < len; index++) {\n        var n = nodes[index];\n        if (!isInvalid(n)) {\n            var newKey = currentKey + keyPrefix + index;\n            if (isArray(n)) {\n                _normalizeVNodes(n, result, 0, newKey);\n            }\n            else {\n                if (isStringOrNumber(n)) {\n                    n = createTextVNode(n, newKey);\n                }\n                else {\n                    var oldKey = n.key;\n                    var isPrefixedKey = isString(oldKey) && oldKey[0] === keyPrefix;\n                    if (n.flags & 81920 /* InUseOrNormalized */ || isPrefixedKey) {\n                        n = directClone(n);\n                    }\n                    n.flags |= 65536 /* Normalized */;\n                    if (!isPrefixedKey) {\n                        if (isNull(oldKey)) {\n                            n.key = newKey;\n                        }\n                        else {\n                            n.key = currentKey + oldKey;\n                        }\n                    }\n                    else if (oldKey.substring(0, currentKey.length) !== currentKey) {\n                        n.key = currentKey + oldKey;\n                    }\n                }\n                result.push(n);\n            }\n        }\n    }\n}\nfunction getFlagsForElementVnode(type) {\n    switch (type) {\n        case 'svg':\n            return 32 /* SvgElement */;\n        case 'input':\n            return 64 /* InputElement */;\n        case 'select':\n            return 256 /* SelectElement */;\n        case 'textarea':\n            return 128 /* TextareaElement */;\n        case Fragment:\n            return 8192 /* Fragment */;\n        default:\n            return 1 /* HtmlElement */;\n    }\n}\nfunction normalizeChildren(vNode, children) {\n    var newChildren;\n    var newChildFlags = 1 /* HasInvalidChildren */;\n    // Don't change children to match strict equal (===) true in patching\n    if (isInvalid(children)) {\n        newChildren = children;\n    }\n    else if (isStringOrNumber(children)) {\n        newChildFlags = 16 /* HasTextChildren */;\n        newChildren = children;\n    }\n    else if (isArray(children)) {\n        var len = children.length;\n        for (var i = 0; i < len; ++i) {\n            var n = children[i];\n            if (isInvalid(n) || isArray(n)) {\n                newChildren = newChildren || children.slice(0, i);\n                _normalizeVNodes(children, newChildren, i, '');\n                break;\n            }\n            else if (isStringOrNumber(n)) {\n                newChildren = newChildren || children.slice(0, i);\n                newChildren.push(createTextVNode(n, keyPrefix + i));\n            }\n            else {\n                var key = n.key;\n                var needsCloning = (n.flags & 81920 /* InUseOrNormalized */) > 0;\n                var isNullKey = isNull(key);\n                var isPrefixed = isString(key) && key[0] === keyPrefix;\n                if (needsCloning || isNullKey || isPrefixed) {\n                    newChildren = newChildren || children.slice(0, i);\n                    if (needsCloning || isPrefixed) {\n                        n = directClone(n);\n                    }\n                    if (isNullKey || isPrefixed) {\n                        n.key = keyPrefix + i;\n                    }\n                    newChildren.push(n);\n                }\n                else if (newChildren) {\n                    newChildren.push(n);\n                }\n                n.flags |= 65536 /* Normalized */;\n            }\n        }\n        newChildren = newChildren || children;\n        if (newChildren.length === 0) {\n            newChildFlags = 1 /* HasInvalidChildren */;\n        }\n        else {\n            newChildFlags = 8 /* HasKeyedChildren */;\n        }\n    }\n    else {\n        newChildren = children;\n        newChildren.flags |= 65536 /* Normalized */;\n        if (children.flags & 81920 /* InUseOrNormalized */) {\n            newChildren = directClone(children);\n        }\n        newChildFlags = 2 /* HasVNodeChildren */;\n    }\n    vNode.children = newChildren;\n    vNode.childFlags = newChildFlags;\n    return vNode;\n}\nfunction normalizeRoot(input) {\n    if (isInvalid(input) || isStringOrNumber(input)) {\n        return createTextVNode(input, null);\n    }\n    if (isArray(input)) {\n        return createFragment(input, 0 /* UnknownChildren */, null);\n    }\n    return input.flags & 16384 /* InUse */ ? directClone(input) : input;\n}\n\nvar xlinkNS = 'http://www.w3.org/1999/xlink';\nvar xmlNS = 'http://www.w3.org/XML/1998/namespace';\nvar namespaces = {\n    'xlink:actuate': xlinkNS,\n    'xlink:arcrole': xlinkNS,\n    'xlink:href': xlinkNS,\n    'xlink:role': xlinkNS,\n    'xlink:show': xlinkNS,\n    'xlink:title': xlinkNS,\n    'xlink:type': xlinkNS,\n    'xml:base': xmlNS,\n    'xml:lang': xmlNS,\n    'xml:space': xmlNS\n};\n\nfunction getDelegatedEventObject(v) {\n    return {\n        onClick: v,\n        onDblClick: v,\n        onFocusIn: v,\n        onFocusOut: v,\n        onKeyDown: v,\n        onKeyPress: v,\n        onKeyUp: v,\n        onMouseDown: v,\n        onMouseMove: v,\n        onMouseUp: v,\n        onTouchEnd: v,\n        onTouchMove: v,\n        onTouchStart: v\n    };\n}\nvar attachedEventCounts = getDelegatedEventObject(0);\nvar attachedEvents = getDelegatedEventObject(null);\nvar syntheticEvents = getDelegatedEventObject(true);\nfunction updateOrAddSyntheticEvent(name, dom) {\n    var eventsObject = dom.$EV;\n    if (!eventsObject) {\n        eventsObject = dom.$EV = getDelegatedEventObject(null);\n    }\n    if (!eventsObject[name]) {\n        if (++attachedEventCounts[name] === 1) {\n            attachedEvents[name] = attachEventToDocument(name);\n        }\n    }\n    return eventsObject;\n}\nfunction unmountSyntheticEvent(name, dom) {\n    var eventsObject = dom.$EV;\n    if (eventsObject && eventsObject[name]) {\n        if (--attachedEventCounts[name] === 0) {\n            document.removeEventListener(normalizeEventName(name), attachedEvents[name]);\n            attachedEvents[name] = null;\n        }\n        eventsObject[name] = null;\n    }\n}\nfunction handleSyntheticEvent(name, lastEvent, nextEvent, dom) {\n    if (isFunction(nextEvent)) {\n        updateOrAddSyntheticEvent(name, dom)[name] = nextEvent;\n    }\n    else if (isLinkEventObject(nextEvent)) {\n        if (isLastValueSameLinkEvent(lastEvent, nextEvent)) {\n            return;\n        }\n        updateOrAddSyntheticEvent(name, dom)[name] = nextEvent;\n    }\n    else {\n        unmountSyntheticEvent(name, dom);\n    }\n}\n// When browsers fully support event.composedPath we could loop it through instead of using parentNode property\nfunction getTargetNode(event) {\n    return isFunction(event.composedPath) ? event.composedPath()[0] : event.target;\n}\nfunction dispatchEvents(event, isClick, name, eventData) {\n    var dom = getTargetNode(event);\n    do {\n        // Html Nodes can be nested fe: span inside button in that scenario browser does not handle disabled attribute on parent,\n        // because the event listener is on document.body\n        // Don't process clicks on disabled elements\n        if (isClick && dom.disabled) {\n            return;\n        }\n        var eventsObject = dom.$EV;\n        if (eventsObject) {\n            var currentEvent = eventsObject[name];\n            if (currentEvent) {\n                // linkEvent object\n                eventData.dom = dom;\n                currentEvent.event ? currentEvent.event(currentEvent.data, event) : currentEvent(event);\n                if (event.cancelBubble) {\n                    return;\n                }\n            }\n        }\n        dom = dom.parentNode;\n    } while (!isNull(dom));\n}\nfunction stopPropagation() {\n    this.cancelBubble = true;\n    if (!this.immediatePropagationStopped) {\n        this.stopImmediatePropagation();\n    }\n}\nfunction isDefaultPrevented() {\n    return this.defaultPrevented;\n}\nfunction isPropagationStopped() {\n    return this.cancelBubble;\n}\nfunction extendEventProperties(event) {\n    // Event data needs to be object to save reference to currentTarget getter\n    var eventData = {\n        dom: document\n    };\n    event.isDefaultPrevented = isDefaultPrevented;\n    event.isPropagationStopped = isPropagationStopped;\n    event.stopPropagation = stopPropagation;\n    Object.defineProperty(event, 'currentTarget', {\n        configurable: true,\n        get: function get() {\n            return eventData.dom;\n        }\n    });\n    return eventData;\n}\nfunction rootClickEvent(name) {\n    return function (event) {\n        if (event.button !== 0) {\n            // Firefox incorrectly triggers click event for mid/right mouse buttons.\n            // This bug has been active for 17 years.\n            // https://bugzilla.mozilla.org/show_bug.cgi?id=184051\n            event.stopPropagation();\n            return;\n        }\n        dispatchEvents(event, true, name, extendEventProperties(event));\n    };\n}\nfunction rootEvent(name) {\n    return function (event) {\n        dispatchEvents(event, false, name, extendEventProperties(event));\n    };\n}\nfunction attachEventToDocument(name) {\n    var attachedEvent = name === 'onClick' || name === 'onDblClick' ? rootClickEvent(name) : rootEvent(name);\n    document.addEventListener(normalizeEventName(name), attachedEvent);\n    return attachedEvent;\n}\n\nfunction isSameInnerHTML(dom, innerHTML) {\n    var tempdom = document.createElement('i');\n    tempdom.innerHTML = innerHTML;\n    return tempdom.innerHTML === dom.innerHTML;\n}\n\nfunction triggerEventListener(props, methodName, e) {\n    if (props[methodName]) {\n        var listener = props[methodName];\n        if (listener.event) {\n            listener.event(listener.data, e);\n        }\n        else {\n            listener(e);\n        }\n    }\n    else {\n        var nativeListenerName = methodName.toLowerCase();\n        if (props[nativeListenerName]) {\n            props[nativeListenerName](e);\n        }\n    }\n}\nfunction createWrappedFunction(methodName, applyValue) {\n    var fnMethod = function (e) {\n        var vNode = this.$V;\n        // If vNode is gone by the time event fires, no-op\n        if (!vNode) {\n            return;\n        }\n        var props = vNode.props || EMPTY_OBJ;\n        var dom = vNode.dom;\n        if (isString(methodName)) {\n            triggerEventListener(props, methodName, e);\n        }\n        else {\n            for (var i = 0; i < methodName.length; ++i) {\n                triggerEventListener(props, methodName[i], e);\n            }\n        }\n        if (isFunction(applyValue)) {\n            var newVNode = this.$V;\n            var newProps = newVNode.props || EMPTY_OBJ;\n            applyValue(newProps, dom, false, newVNode);\n        }\n    };\n    Object.defineProperty(fnMethod, 'wrapped', {\n        configurable: false,\n        enumerable: false,\n        value: true,\n        writable: false\n    });\n    return fnMethod;\n}\n\nfunction attachEvent(dom, eventName, handler) {\n    var previousKey = \"$\" + eventName;\n    var previousArgs = dom[previousKey];\n    if (previousArgs) {\n        if (previousArgs[1].wrapped) {\n            return;\n        }\n        dom.removeEventListener(previousArgs[0], previousArgs[1]);\n        dom[previousKey] = null;\n    }\n    if (isFunction(handler)) {\n        dom.addEventListener(eventName, handler);\n        dom[previousKey] = [eventName, handler];\n    }\n}\n\nfunction isCheckedType(type) {\n    return type === 'checkbox' || type === 'radio';\n}\nvar onTextInputChange = createWrappedFunction('onInput', applyValueInput);\nvar wrappedOnChange = createWrappedFunction(['onClick', 'onChange'], applyValueInput);\n/* tslint:disable-next-line:no-empty */\nfunction emptywrapper(event) {\n    event.stopPropagation();\n}\nemptywrapper.wrapped = true;\nfunction inputEvents(dom, nextPropsOrEmpty) {\n    if (isCheckedType(nextPropsOrEmpty.type)) {\n        attachEvent(dom, 'change', wrappedOnChange);\n        attachEvent(dom, 'click', emptywrapper);\n    }\n    else {\n        attachEvent(dom, 'input', onTextInputChange);\n    }\n}\nfunction applyValueInput(nextPropsOrEmpty, dom) {\n    var type = nextPropsOrEmpty.type;\n    var value = nextPropsOrEmpty.value;\n    var checked = nextPropsOrEmpty.checked;\n    var multiple = nextPropsOrEmpty.multiple;\n    var defaultValue = nextPropsOrEmpty.defaultValue;\n    var hasValue = !isNullOrUndef(value);\n    if (type && type !== dom.type) {\n        dom.setAttribute('type', type);\n    }\n    if (!isNullOrUndef(multiple) && multiple !== dom.multiple) {\n        dom.multiple = multiple;\n    }\n    if (!isNullOrUndef(defaultValue) && !hasValue) {\n        dom.defaultValue = defaultValue + '';\n    }\n    if (isCheckedType(type)) {\n        if (hasValue) {\n            dom.value = value;\n        }\n        if (!isNullOrUndef(checked)) {\n            dom.checked = checked;\n        }\n    }\n    else {\n        if (hasValue && dom.value !== value) {\n            dom.defaultValue = value;\n            dom.value = value;\n        }\n        else if (!isNullOrUndef(checked)) {\n            dom.checked = checked;\n        }\n    }\n}\n\nfunction updateChildOptions(vNode, value) {\n    if (vNode.type === 'option') {\n        updateChildOption(vNode, value);\n    }\n    else {\n        var children = vNode.children;\n        var flags = vNode.flags;\n        if (flags & 4 /* ComponentClass */) {\n            updateChildOptions(children.$LI, value);\n        }\n        else if (flags & 8 /* ComponentFunction */) {\n            updateChildOptions(children, value);\n        }\n        else if (vNode.childFlags === 2 /* HasVNodeChildren */) {\n            updateChildOptions(children, value);\n        }\n        else if (vNode.childFlags & 12 /* MultipleChildren */) {\n            for (var i = 0, len = children.length; i < len; ++i) {\n                updateChildOptions(children[i], value);\n            }\n        }\n    }\n}\nfunction updateChildOption(vNode, value) {\n    var props = vNode.props || EMPTY_OBJ;\n    var dom = vNode.dom;\n    // we do this as multiple may have changed\n    dom.value = props.value;\n    if (props.value === value || (isArray(value) && value.indexOf(props.value) !== -1)) {\n        dom.selected = true;\n    }\n    else if (!isNullOrUndef(value) || !isNullOrUndef(props.selected)) {\n        dom.selected = props.selected || false;\n    }\n}\nvar onSelectChange = createWrappedFunction('onChange', applyValueSelect);\nfunction selectEvents(dom) {\n    attachEvent(dom, 'change', onSelectChange);\n}\nfunction applyValueSelect(nextPropsOrEmpty, dom, mounting, vNode) {\n    var multiplePropInBoolean = Boolean(nextPropsOrEmpty.multiple);\n    if (!isNullOrUndef(nextPropsOrEmpty.multiple) && multiplePropInBoolean !== dom.multiple) {\n        dom.multiple = multiplePropInBoolean;\n    }\n    var index = nextPropsOrEmpty.selectedIndex;\n    if (index === -1) {\n        dom.selectedIndex = -1;\n    }\n    var childFlags = vNode.childFlags;\n    if (childFlags !== 1 /* HasInvalidChildren */) {\n        var value = nextPropsOrEmpty.value;\n        if (isNumber(index) && index > -1 && dom.options[index]) {\n            value = dom.options[index].value;\n        }\n        if (mounting && isNullOrUndef(value)) {\n            value = nextPropsOrEmpty.defaultValue;\n        }\n        updateChildOptions(vNode, value);\n    }\n}\n\nvar onTextareaInputChange = createWrappedFunction('onInput', applyValueTextArea);\nvar wrappedOnChange$1 = createWrappedFunction('onChange');\nfunction textAreaEvents(dom, nextPropsOrEmpty) {\n    attachEvent(dom, 'input', onTextareaInputChange);\n    if (nextPropsOrEmpty.onChange) {\n        attachEvent(dom, 'change', wrappedOnChange$1);\n    }\n}\nfunction applyValueTextArea(nextPropsOrEmpty, dom, mounting) {\n    var value = nextPropsOrEmpty.value;\n    var domValue = dom.value;\n    if (isNullOrUndef(value)) {\n        if (mounting) {\n            var defaultValue = nextPropsOrEmpty.defaultValue;\n            if (!isNullOrUndef(defaultValue) && defaultValue !== domValue) {\n                dom.defaultValue = defaultValue;\n                dom.value = defaultValue;\n            }\n        }\n    }\n    else if (domValue !== value) {\n        /* There is value so keep it controlled */\n        dom.defaultValue = value;\n        dom.value = value;\n    }\n}\n\nfunction processElement(flags, vNode, dom, nextPropsOrEmpty, mounting, isControlled) {\n    if (flags & 64 /* InputElement */) {\n        applyValueInput(nextPropsOrEmpty, dom);\n    }\n    else if (flags & 256 /* SelectElement */) {\n        applyValueSelect(nextPropsOrEmpty, dom, mounting, vNode);\n    }\n    else if (flags & 128 /* TextareaElement */) {\n        applyValueTextArea(nextPropsOrEmpty, dom, mounting);\n    }\n    if (isControlled) {\n        dom.$V = vNode;\n    }\n}\nfunction addFormElementEventHandlers(flags, dom, nextPropsOrEmpty) {\n    if (flags & 64 /* InputElement */) {\n        inputEvents(dom, nextPropsOrEmpty);\n    }\n    else if (flags & 256 /* SelectElement */) {\n        selectEvents(dom);\n    }\n    else if (flags & 128 /* TextareaElement */) {\n        textAreaEvents(dom, nextPropsOrEmpty);\n    }\n}\nfunction isControlledFormElement(nextPropsOrEmpty) {\n    return nextPropsOrEmpty.type && isCheckedType(nextPropsOrEmpty.type) ? !isNullOrUndef(nextPropsOrEmpty.checked) : !isNullOrUndef(nextPropsOrEmpty.value);\n}\n\nfunction createRef() {\n    return {\n        current: null\n    };\n}\nfunction forwardRef(render) {\n    // @ts-ignore\n    return {\n        render: render\n    };\n}\nfunction unmountRef(ref) {\n    if (ref) {\n        if (!safeCall1(ref, null) && ref.current) {\n            ref.current = null;\n        }\n    }\n}\nfunction mountRef(ref, value, lifecycle) {\n    if (ref && (isFunction(ref) || ref.current !== void 0)) {\n        lifecycle.push(function () {\n            if (!safeCall1(ref, value) && ref.current !== void 0) {\n                ref.current = value;\n            }\n        });\n    }\n}\n\nfunction remove(vNode, parentDOM) {\n    unmount(vNode);\n    removeVNodeDOM(vNode, parentDOM);\n}\nfunction unmount(vNode) {\n    var flags = vNode.flags;\n    var children = vNode.children;\n    var ref;\n    if (flags & 481 /* Element */) {\n        ref = vNode.ref;\n        var props = vNode.props;\n        unmountRef(ref);\n        var childFlags = vNode.childFlags;\n        if (!isNull(props)) {\n            var keys = Object.keys(props);\n            for (var i = 0, len = keys.length; i < len; i++) {\n                var key = keys[i];\n                if (syntheticEvents[key]) {\n                    unmountSyntheticEvent(key, vNode.dom);\n                }\n            }\n        }\n        if (childFlags & 12 /* MultipleChildren */) {\n            unmountAllChildren(children);\n        }\n        else if (childFlags === 2 /* HasVNodeChildren */) {\n            unmount(children);\n        }\n    }\n    else if (children) {\n        if (flags & 4 /* ComponentClass */) {\n            if (isFunction(children.componentWillUnmount)) {\n                children.componentWillUnmount();\n            }\n            unmountRef(vNode.ref);\n            children.$UN = true;\n            unmount(children.$LI);\n        }\n        else if (flags & 8 /* ComponentFunction */) {\n            ref = vNode.ref;\n            if (!isNullOrUndef(ref) && isFunction(ref.onComponentWillUnmount)) {\n                ref.onComponentWillUnmount(findDOMfromVNode(vNode, true), vNode.props || EMPTY_OBJ);\n            }\n            unmount(children);\n        }\n        else if (flags & 1024 /* Portal */) {\n            remove(children, vNode.ref);\n        }\n        else if (flags & 8192 /* Fragment */) {\n            if (vNode.childFlags & 12 /* MultipleChildren */) {\n                unmountAllChildren(children);\n            }\n        }\n    }\n}\nfunction unmountAllChildren(children) {\n    for (var i = 0, len = children.length; i < len; ++i) {\n        unmount(children[i]);\n    }\n}\nfunction clearDOM(dom) {\n    // Optimization for clearing dom\n    dom.textContent = '';\n}\nfunction removeAllChildren(dom, vNode, children) {\n    unmountAllChildren(children);\n    if (vNode.flags & 8192 /* Fragment */) {\n        removeVNodeDOM(vNode, dom);\n    }\n    else {\n        clearDOM(dom);\n    }\n}\n\nfunction wrapLinkEvent(nextValue) {\n    // This variable makes sure there is no \"this\" context in callback\n    var ev = nextValue.event;\n    return function (e) {\n        ev(nextValue.data, e);\n    };\n}\nfunction patchEvent(name, lastValue, nextValue, dom) {\n    if (isLinkEventObject(nextValue)) {\n        if (isLastValueSameLinkEvent(lastValue, nextValue)) {\n            return;\n        }\n        nextValue = wrapLinkEvent(nextValue);\n    }\n    attachEvent(dom, normalizeEventName(name), nextValue);\n}\n// We are assuming here that we come from patchProp routine\n// -nextAttrValue cannot be null or undefined\nfunction patchStyle(lastAttrValue, nextAttrValue, dom) {\n    if (isNullOrUndef(nextAttrValue)) {\n        dom.removeAttribute('style');\n        return;\n    }\n    var domStyle = dom.style;\n    var style;\n    var value;\n    if (isString(nextAttrValue)) {\n        domStyle.cssText = nextAttrValue;\n        return;\n    }\n    if (!isNullOrUndef(lastAttrValue) && !isString(lastAttrValue)) {\n        for (style in nextAttrValue) {\n            // do not add a hasOwnProperty check here, it affects performance\n            value = nextAttrValue[style];\n            if (value !== lastAttrValue[style]) {\n                domStyle.setProperty(style, value);\n            }\n        }\n        for (style in lastAttrValue) {\n            if (isNullOrUndef(nextAttrValue[style])) {\n                domStyle.removeProperty(style);\n            }\n        }\n    }\n    else {\n        for (style in nextAttrValue) {\n            value = nextAttrValue[style];\n            domStyle.setProperty(style, value);\n        }\n    }\n}\nfunction patchDangerInnerHTML(lastValue, nextValue, lastVNode, dom) {\n    var lastHtml = (lastValue && lastValue.__html) || '';\n    var nextHtml = (nextValue && nextValue.__html) || '';\n    if (lastHtml !== nextHtml) {\n        if (!isNullOrUndef(nextHtml) && !isSameInnerHTML(dom, nextHtml)) {\n            if (!isNull(lastVNode)) {\n                if (lastVNode.childFlags & 12 /* MultipleChildren */) {\n                    unmountAllChildren(lastVNode.children);\n                }\n                else if (lastVNode.childFlags === 2 /* HasVNodeChildren */) {\n                    unmount(lastVNode.children);\n                }\n                lastVNode.children = null;\n                lastVNode.childFlags = 1 /* HasInvalidChildren */;\n            }\n            dom.innerHTML = nextHtml;\n        }\n    }\n}\nfunction patchProp(prop, lastValue, nextValue, dom, isSVG, hasControlledValue, lastVNode) {\n    switch (prop) {\n        case 'children':\n        case 'childrenType':\n        case 'className':\n        case 'defaultValue':\n        case 'key':\n        case 'multiple':\n        case 'ref':\n        case 'selectedIndex':\n            break;\n        case 'autoFocus':\n            dom.autofocus = !!nextValue;\n            break;\n        case 'allowfullscreen':\n        case 'autoplay':\n        case 'capture':\n        case 'checked':\n        case 'controls':\n        case 'default':\n        case 'disabled':\n        case 'hidden':\n        case 'indeterminate':\n        case 'loop':\n        case 'muted':\n        case 'novalidate':\n        case 'open':\n        case 'readOnly':\n        case 'required':\n        case 'reversed':\n        case 'scoped':\n        case 'seamless':\n        case 'selected':\n            dom[prop] = !!nextValue;\n            break;\n        case 'defaultChecked':\n        case 'value':\n        case 'volume':\n            if (hasControlledValue && prop === 'value') {\n                break;\n            }\n            var value = isNullOrUndef(nextValue) ? '' : nextValue;\n            if (dom[prop] !== value) {\n                dom[prop] = value;\n            }\n            break;\n        case 'style':\n            patchStyle(lastValue, nextValue, dom);\n            break;\n        case 'dangerouslySetInnerHTML':\n            patchDangerInnerHTML(lastValue, nextValue, lastVNode, dom);\n            break;\n        default:\n            if (syntheticEvents[prop]) {\n                handleSyntheticEvent(prop, lastValue, nextValue, dom);\n            }\n            else if (prop.charCodeAt(0) === 111 && prop.charCodeAt(1) === 110) {\n                patchEvent(prop, lastValue, nextValue, dom);\n            }\n            else if (isNullOrUndef(nextValue)) {\n                dom.removeAttribute(prop);\n            }\n            else if (isSVG && namespaces[prop]) {\n                // We optimize for isSVG being false\n                // If we end up in this path we can read property again\n                dom.setAttributeNS(namespaces[prop], prop, nextValue);\n            }\n            else {\n                dom.setAttribute(prop, nextValue);\n            }\n            break;\n    }\n}\nfunction mountProps(vNode, flags, props, dom, isSVG) {\n    var hasControlledValue = false;\n    var isFormElement = (flags & 448 /* FormElement */) > 0;\n    if (isFormElement) {\n        hasControlledValue = isControlledFormElement(props);\n        if (hasControlledValue) {\n            addFormElementEventHandlers(flags, dom, props);\n        }\n    }\n    for (var prop in props) {\n        // do not add a hasOwnProperty check here, it affects performance\n        patchProp(prop, null, props[prop], dom, isSVG, hasControlledValue, null);\n    }\n    if (isFormElement) {\n        processElement(flags, vNode, dom, props, true, hasControlledValue);\n    }\n}\n\nfunction renderNewInput(instance, props, context) {\n    var nextInput = normalizeRoot(instance.render(props, instance.state, context));\n    var childContext = context;\n    if (isFunction(instance.getChildContext)) {\n        childContext = combineFrom(context, instance.getChildContext());\n    }\n    instance.$CX = childContext;\n    return nextInput;\n}\nfunction createClassComponentInstance(vNode, Component, props, context, isSVG, lifecycle) {\n    var instance = new Component(props, context);\n    var usesNewAPI = (instance.$N = Boolean(Component.getDerivedStateFromProps || instance.getSnapshotBeforeUpdate));\n    instance.$SVG = isSVG;\n    instance.$L = lifecycle;\n    vNode.children = instance;\n    instance.$BS = false;\n    instance.context = context;\n    if (instance.props === EMPTY_OBJ) {\n        instance.props = props;\n    }\n    if (!usesNewAPI) {\n        if (isFunction(instance.componentWillMount)) {\n            instance.$BR = true;\n            instance.componentWillMount();\n            var pending = instance.$PS;\n            if (!isNull(pending)) {\n                var state = instance.state;\n                if (isNull(state)) {\n                    instance.state = pending;\n                }\n                else {\n                    for (var key in pending) {\n                        state[key] = pending[key];\n                    }\n                }\n                instance.$PS = null;\n            }\n            instance.$BR = false;\n        }\n    }\n    else {\n        instance.state = createDerivedState(instance, props, instance.state);\n    }\n    instance.$LI = renderNewInput(instance, props, context);\n    return instance;\n}\nfunction renderFunctionalComponent(vNode, context) {\n    var props = vNode.props || EMPTY_OBJ;\n    return vNode.flags & 32768 /* ForwardRef */ ? vNode.type.render(props, vNode.ref, context) : vNode.type(props, context);\n}\n\nfunction mount(vNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var flags = (vNode.flags |= 16384 /* InUse */);\n    if (flags & 481 /* Element */) {\n        mountElement(vNode, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n    else if (flags & 4 /* ComponentClass */) {\n        mountClassComponent(vNode, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n    else if (flags & 8 /* ComponentFunction */) {\n        mountFunctionalComponent(vNode, parentDOM, context, isSVG, nextNode, lifecycle);\n        mountFunctionalComponentCallbacks(vNode, lifecycle);\n    }\n    else if (flags & 512 /* Void */ || flags & 16 /* Text */) {\n        mountText(vNode, parentDOM, nextNode);\n    }\n    else if (flags & 8192 /* Fragment */) {\n        mountFragment(vNode, context, parentDOM, isSVG, nextNode, lifecycle);\n    }\n    else if (flags & 1024 /* Portal */) {\n        mountPortal(vNode, context, parentDOM, nextNode, lifecycle);\n    }\n    else ;\n}\nfunction mountPortal(vNode, context, parentDOM, nextNode, lifecycle) {\n    mount(vNode.children, vNode.ref, context, false, null, lifecycle);\n    var placeHolderVNode = createVoidVNode();\n    mountText(placeHolderVNode, parentDOM, nextNode);\n    vNode.dom = placeHolderVNode.dom;\n}\nfunction mountFragment(vNode, context, parentDOM, isSVG, nextNode, lifecycle) {\n    var children = vNode.children;\n    var childFlags = vNode.childFlags;\n    // When fragment is optimized for multiple children, check if there is no children and change flag to invalid\n    // This is the only normalization always done, to keep optimization flags API same for fragments and regular elements\n    if (childFlags & 12 /* MultipleChildren */ && children.length === 0) {\n        childFlags = vNode.childFlags = 2 /* HasVNodeChildren */;\n        children = vNode.children = createVoidVNode();\n    }\n    if (childFlags === 2 /* HasVNodeChildren */) {\n        mount(children, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n    else {\n        mountArrayChildren(children, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n}\nfunction mountText(vNode, parentDOM, nextNode) {\n    var dom = (vNode.dom = document.createTextNode(vNode.children));\n    if (!isNull(parentDOM)) {\n        insertOrAppend(parentDOM, dom, nextNode);\n    }\n}\nfunction mountElement(vNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var flags = vNode.flags;\n    var props = vNode.props;\n    var className = vNode.className;\n    var childFlags = vNode.childFlags;\n    var dom = (vNode.dom = documentCreateElement(vNode.type, (isSVG = isSVG || (flags & 32 /* SvgElement */) > 0)));\n    var children = vNode.children;\n    if (!isNullOrUndef(className) && className !== '') {\n        if (isSVG) {\n            dom.setAttribute('class', className);\n        }\n        else {\n            dom.className = className;\n        }\n    }\n    if (childFlags === 16 /* HasTextChildren */) {\n        setTextContent(dom, children);\n    }\n    else if (childFlags !== 1 /* HasInvalidChildren */) {\n        var childrenIsSVG = isSVG && vNode.type !== 'foreignObject';\n        if (childFlags === 2 /* HasVNodeChildren */) {\n            if (children.flags & 16384 /* InUse */) {\n                vNode.children = children = directClone(children);\n            }\n            mount(children, dom, context, childrenIsSVG, null, lifecycle);\n        }\n        else if (childFlags === 8 /* HasKeyedChildren */ || childFlags === 4 /* HasNonKeyedChildren */) {\n            mountArrayChildren(children, dom, context, childrenIsSVG, null, lifecycle);\n        }\n    }\n    if (!isNull(parentDOM)) {\n        insertOrAppend(parentDOM, dom, nextNode);\n    }\n    if (!isNull(props)) {\n        mountProps(vNode, flags, props, dom, isSVG);\n    }\n    mountRef(vNode.ref, dom, lifecycle);\n}\nfunction mountArrayChildren(children, dom, context, isSVG, nextNode, lifecycle) {\n    for (var i = 0; i < children.length; ++i) {\n        var child = children[i];\n        if (child.flags & 16384 /* InUse */) {\n            children[i] = child = directClone(child);\n        }\n        mount(child, dom, context, isSVG, nextNode, lifecycle);\n    }\n}\nfunction mountClassComponent(vNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var instance = createClassComponentInstance(vNode, vNode.type, vNode.props || EMPTY_OBJ, context, isSVG, lifecycle);\n    mount(instance.$LI, parentDOM, instance.$CX, isSVG, nextNode, lifecycle);\n    mountClassComponentCallbacks(vNode.ref, instance, lifecycle);\n}\nfunction mountFunctionalComponent(vNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    mount((vNode.children = normalizeRoot(renderFunctionalComponent(vNode, context))), parentDOM, context, isSVG, nextNode, lifecycle);\n}\nfunction createClassMountCallback(instance) {\n    return function () {\n        instance.componentDidMount();\n    };\n}\nfunction mountClassComponentCallbacks(ref, instance, lifecycle) {\n    mountRef(ref, instance, lifecycle);\n    if (isFunction(instance.componentDidMount)) {\n        lifecycle.push(createClassMountCallback(instance));\n    }\n}\nfunction createOnMountCallback(ref, vNode) {\n    return function () {\n        ref.onComponentDidMount(findDOMfromVNode(vNode, true), vNode.props || EMPTY_OBJ);\n    };\n}\nfunction mountFunctionalComponentCallbacks(vNode, lifecycle) {\n    var ref = vNode.ref;\n    if (!isNullOrUndef(ref)) {\n        safeCall1(ref.onComponentWillMount, vNode.props || EMPTY_OBJ);\n        if (isFunction(ref.onComponentDidMount)) {\n            lifecycle.push(createOnMountCallback(ref, vNode));\n        }\n    }\n}\n\nfunction replaceWithNewNode(lastVNode, nextVNode, parentDOM, context, isSVG, lifecycle) {\n    unmount(lastVNode);\n    if ((nextVNode.flags & lastVNode.flags & 2033 /* DOMRef */) !== 0) {\n        mount(nextVNode, null, context, isSVG, null, lifecycle);\n        // Single DOM operation, when we have dom references available\n        replaceChild(parentDOM, nextVNode.dom, lastVNode.dom);\n    }\n    else {\n        mount(nextVNode, parentDOM, context, isSVG, findDOMfromVNode(lastVNode, true), lifecycle);\n        removeVNodeDOM(lastVNode, parentDOM);\n    }\n}\nfunction patch(lastVNode, nextVNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var nextFlags = (nextVNode.flags |= 16384 /* InUse */);\n    if (lastVNode.flags !== nextFlags || lastVNode.type !== nextVNode.type || lastVNode.key !== nextVNode.key || nextFlags & 2048 /* ReCreate */) {\n        if (lastVNode.flags & 16384 /* InUse */) {\n            replaceWithNewNode(lastVNode, nextVNode, parentDOM, context, isSVG, lifecycle);\n        }\n        else {\n            // Last vNode is not in use, it has crashed at application level. Just mount nextVNode and ignore last one\n            mount(nextVNode, parentDOM, context, isSVG, nextNode, lifecycle);\n        }\n    }\n    else if (nextFlags & 481 /* Element */) {\n        patchElement(lastVNode, nextVNode, context, isSVG, nextFlags, lifecycle);\n    }\n    else if (nextFlags & 4 /* ComponentClass */) {\n        patchClassComponent(lastVNode, nextVNode, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n    else if (nextFlags & 8 /* ComponentFunction */) {\n        patchFunctionalComponent(lastVNode, nextVNode, parentDOM, context, isSVG, nextNode, lifecycle);\n    }\n    else if (nextFlags & 16 /* Text */) {\n        patchText(lastVNode, nextVNode);\n    }\n    else if (nextFlags & 512 /* Void */) {\n        nextVNode.dom = lastVNode.dom;\n    }\n    else if (nextFlags & 8192 /* Fragment */) {\n        patchFragment(lastVNode, nextVNode, parentDOM, context, isSVG, lifecycle);\n    }\n    else {\n        patchPortal(lastVNode, nextVNode, context, lifecycle);\n    }\n}\nfunction patchSingleTextChild(lastChildren, nextChildren, parentDOM) {\n    if (lastChildren !== nextChildren) {\n        if (lastChildren !== '') {\n            parentDOM.firstChild.nodeValue = nextChildren;\n        }\n        else {\n            setTextContent(parentDOM, nextChildren);\n        }\n    }\n}\nfunction patchContentEditableChildren(dom, nextChildren) {\n    if (dom.textContent !== nextChildren) {\n        dom.textContent = nextChildren;\n    }\n}\nfunction patchFragment(lastVNode, nextVNode, parentDOM, context, isSVG, lifecycle) {\n    var lastChildren = lastVNode.children;\n    var nextChildren = nextVNode.children;\n    var lastChildFlags = lastVNode.childFlags;\n    var nextChildFlags = nextVNode.childFlags;\n    var nextNode = null;\n    // When fragment is optimized for multiple children, check if there is no children and change flag to invalid\n    // This is the only normalization always done, to keep optimization flags API same for fragments and regular elements\n    if (nextChildFlags & 12 /* MultipleChildren */ && nextChildren.length === 0) {\n        nextChildFlags = nextVNode.childFlags = 2 /* HasVNodeChildren */;\n        nextChildren = nextVNode.children = createVoidVNode();\n    }\n    var nextIsSingle = (nextChildFlags & 2 /* HasVNodeChildren */) !== 0;\n    if (lastChildFlags & 12 /* MultipleChildren */) {\n        var lastLen = lastChildren.length;\n        // We need to know Fragment's edge node when\n        if (\n        // It uses keyed algorithm\n        (lastChildFlags & 8 /* HasKeyedChildren */ && nextChildFlags & 8 /* HasKeyedChildren */) ||\n            // It transforms from many to single\n            nextIsSingle ||\n            // It will append more nodes\n            (!nextIsSingle && nextChildren.length > lastLen)) {\n            // When fragment has multiple children there is always at least one vNode\n            nextNode = findDOMfromVNode(lastChildren[lastLen - 1], false).nextSibling;\n        }\n    }\n    patchChildren(lastChildFlags, nextChildFlags, lastChildren, nextChildren, parentDOM, context, isSVG, nextNode, lastVNode, lifecycle);\n}\nfunction patchPortal(lastVNode, nextVNode, context, lifecycle) {\n    var lastContainer = lastVNode.ref;\n    var nextContainer = nextVNode.ref;\n    var nextChildren = nextVNode.children;\n    patchChildren(lastVNode.childFlags, nextVNode.childFlags, lastVNode.children, nextChildren, lastContainer, context, false, null, lastVNode, lifecycle);\n    nextVNode.dom = lastVNode.dom;\n    if (lastContainer !== nextContainer && !isInvalid(nextChildren)) {\n        var node = nextChildren.dom;\n        removeChild(lastContainer, node);\n        appendChild(nextContainer, node);\n    }\n}\nfunction patchElement(lastVNode, nextVNode, context, isSVG, nextFlags, lifecycle) {\n    var dom = (nextVNode.dom = lastVNode.dom);\n    var lastProps = lastVNode.props;\n    var nextProps = nextVNode.props;\n    var isFormElement = false;\n    var hasControlledValue = false;\n    var nextPropsOrEmpty;\n    isSVG = isSVG || (nextFlags & 32 /* SvgElement */) > 0;\n    // inlined patchProps  -- starts --\n    if (lastProps !== nextProps) {\n        var lastPropsOrEmpty = lastProps || EMPTY_OBJ;\n        nextPropsOrEmpty = nextProps || EMPTY_OBJ;\n        if (nextPropsOrEmpty !== EMPTY_OBJ) {\n            isFormElement = (nextFlags & 448 /* FormElement */) > 0;\n            if (isFormElement) {\n                hasControlledValue = isControlledFormElement(nextPropsOrEmpty);\n            }\n            for (var prop in nextPropsOrEmpty) {\n                var lastValue = lastPropsOrEmpty[prop];\n                var nextValue = nextPropsOrEmpty[prop];\n                if (lastValue !== nextValue) {\n                    patchProp(prop, lastValue, nextValue, dom, isSVG, hasControlledValue, lastVNode);\n                }\n            }\n        }\n        if (lastPropsOrEmpty !== EMPTY_OBJ) {\n            for (var prop$1 in lastPropsOrEmpty) {\n                if (isNullOrUndef(nextPropsOrEmpty[prop$1]) && !isNullOrUndef(lastPropsOrEmpty[prop$1])) {\n                    patchProp(prop$1, lastPropsOrEmpty[prop$1], null, dom, isSVG, hasControlledValue, lastVNode);\n                }\n            }\n        }\n    }\n    var nextChildren = nextVNode.children;\n    var nextClassName = nextVNode.className;\n    // inlined patchProps  -- ends --\n    if (lastVNode.className !== nextClassName) {\n        if (isNullOrUndef(nextClassName)) {\n            dom.removeAttribute('class');\n        }\n        else if (isSVG) {\n            dom.setAttribute('class', nextClassName);\n        }\n        else {\n            dom.className = nextClassName;\n        }\n    }\n    if (nextFlags & 4096 /* ContentEditable */) {\n        patchContentEditableChildren(dom, nextChildren);\n    }\n    else {\n        patchChildren(lastVNode.childFlags, nextVNode.childFlags, lastVNode.children, nextChildren, dom, context, isSVG && nextVNode.type !== 'foreignObject', null, lastVNode, lifecycle);\n    }\n    if (isFormElement) {\n        processElement(nextFlags, nextVNode, dom, nextPropsOrEmpty, false, hasControlledValue);\n    }\n    var nextRef = nextVNode.ref;\n    var lastRef = lastVNode.ref;\n    if (lastRef !== nextRef) {\n        unmountRef(lastRef);\n        mountRef(nextRef, dom, lifecycle);\n    }\n}\nfunction replaceOneVNodeWithMultipleVNodes(lastChildren, nextChildren, parentDOM, context, isSVG, lifecycle) {\n    unmount(lastChildren);\n    mountArrayChildren(nextChildren, parentDOM, context, isSVG, findDOMfromVNode(lastChildren, true), lifecycle);\n    removeVNodeDOM(lastChildren, parentDOM);\n}\nfunction patchChildren(lastChildFlags, nextChildFlags, lastChildren, nextChildren, parentDOM, context, isSVG, nextNode, parentVNode, lifecycle) {\n    switch (lastChildFlags) {\n        case 2 /* HasVNodeChildren */:\n            switch (nextChildFlags) {\n                case 2 /* HasVNodeChildren */:\n                    patch(lastChildren, nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n                case 1 /* HasInvalidChildren */:\n                    remove(lastChildren, parentDOM);\n                    break;\n                case 16 /* HasTextChildren */:\n                    unmount(lastChildren);\n                    setTextContent(parentDOM, nextChildren);\n                    break;\n                default:\n                    replaceOneVNodeWithMultipleVNodes(lastChildren, nextChildren, parentDOM, context, isSVG, lifecycle);\n                    break;\n            }\n            break;\n        case 1 /* HasInvalidChildren */:\n            switch (nextChildFlags) {\n                case 2 /* HasVNodeChildren */:\n                    mount(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n                case 1 /* HasInvalidChildren */:\n                    break;\n                case 16 /* HasTextChildren */:\n                    setTextContent(parentDOM, nextChildren);\n                    break;\n                default:\n                    mountArrayChildren(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n            }\n            break;\n        case 16 /* HasTextChildren */:\n            switch (nextChildFlags) {\n                case 16 /* HasTextChildren */:\n                    patchSingleTextChild(lastChildren, nextChildren, parentDOM);\n                    break;\n                case 2 /* HasVNodeChildren */:\n                    clearDOM(parentDOM);\n                    mount(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n                case 1 /* HasInvalidChildren */:\n                    clearDOM(parentDOM);\n                    break;\n                default:\n                    clearDOM(parentDOM);\n                    mountArrayChildren(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n            }\n            break;\n        default:\n            switch (nextChildFlags) {\n                case 16 /* HasTextChildren */:\n                    unmountAllChildren(lastChildren);\n                    setTextContent(parentDOM, nextChildren);\n                    break;\n                case 2 /* HasVNodeChildren */:\n                    removeAllChildren(parentDOM, parentVNode, lastChildren);\n                    mount(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                    break;\n                case 1 /* HasInvalidChildren */:\n                    removeAllChildren(parentDOM, parentVNode, lastChildren);\n                    break;\n                default:\n                    var lastLength = lastChildren.length | 0;\n                    var nextLength = nextChildren.length | 0;\n                    // Fast path's for both algorithms\n                    if (lastLength === 0) {\n                        if (nextLength > 0) {\n                            mountArrayChildren(nextChildren, parentDOM, context, isSVG, nextNode, lifecycle);\n                        }\n                    }\n                    else if (nextLength === 0) {\n                        removeAllChildren(parentDOM, parentVNode, lastChildren);\n                    }\n                    else if (nextChildFlags === 8 /* HasKeyedChildren */ && lastChildFlags === 8 /* HasKeyedChildren */) {\n                        patchKeyedChildren(lastChildren, nextChildren, parentDOM, context, isSVG, lastLength, nextLength, nextNode, parentVNode, lifecycle);\n                    }\n                    else {\n                        patchNonKeyedChildren(lastChildren, nextChildren, parentDOM, context, isSVG, lastLength, nextLength, nextNode, lifecycle);\n                    }\n                    break;\n            }\n            break;\n    }\n}\nfunction createDidUpdate(instance, lastProps, lastState, snapshot, lifecycle) {\n    lifecycle.push(function () {\n        instance.componentDidUpdate(lastProps, lastState, snapshot);\n    });\n}\nfunction updateClassComponent(instance, nextState, nextProps, parentDOM, context, isSVG, force, nextNode, lifecycle) {\n    var lastState = instance.state;\n    var lastProps = instance.props;\n    var usesNewAPI = Boolean(instance.$N);\n    var hasSCU = isFunction(instance.shouldComponentUpdate);\n    if (usesNewAPI) {\n        nextState = createDerivedState(instance, nextProps, nextState !== lastState ? combineFrom(lastState, nextState) : nextState);\n    }\n    if (force || !hasSCU || (hasSCU && instance.shouldComponentUpdate(nextProps, nextState, context))) {\n        if (!usesNewAPI && isFunction(instance.componentWillUpdate)) {\n            instance.componentWillUpdate(nextProps, nextState, context);\n        }\n        instance.props = nextProps;\n        instance.state = nextState;\n        instance.context = context;\n        var snapshot = null;\n        var nextInput = renderNewInput(instance, nextProps, context);\n        if (usesNewAPI && isFunction(instance.getSnapshotBeforeUpdate)) {\n            snapshot = instance.getSnapshotBeforeUpdate(lastProps, lastState);\n        }\n        patch(instance.$LI, nextInput, parentDOM, instance.$CX, isSVG, nextNode, lifecycle);\n        // Dont update Last input, until patch has been succesfully executed\n        instance.$LI = nextInput;\n        if (isFunction(instance.componentDidUpdate)) {\n            createDidUpdate(instance, lastProps, lastState, snapshot, lifecycle);\n        }\n    }\n    else {\n        instance.props = nextProps;\n        instance.state = nextState;\n        instance.context = context;\n    }\n}\nfunction patchClassComponent(lastVNode, nextVNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var instance = (nextVNode.children = lastVNode.children);\n    // If Component has crashed, ignore it to stay functional\n    if (isNull(instance)) {\n        return;\n    }\n    instance.$L = lifecycle;\n    var nextProps = nextVNode.props || EMPTY_OBJ;\n    var nextRef = nextVNode.ref;\n    var lastRef = lastVNode.ref;\n    var nextState = instance.state;\n    if (!instance.$N) {\n        if (isFunction(instance.componentWillReceiveProps)) {\n            instance.$BR = true;\n            instance.componentWillReceiveProps(nextProps, context);\n            // If instance component was removed during its own update do nothing.\n            if (instance.$UN) {\n                return;\n            }\n            instance.$BR = false;\n        }\n        if (!isNull(instance.$PS)) {\n            nextState = combineFrom(nextState, instance.$PS);\n            instance.$PS = null;\n        }\n    }\n    updateClassComponent(instance, nextState, nextProps, parentDOM, context, isSVG, false, nextNode, lifecycle);\n    if (lastRef !== nextRef) {\n        unmountRef(lastRef);\n        mountRef(nextRef, instance, lifecycle);\n    }\n}\nfunction patchFunctionalComponent(lastVNode, nextVNode, parentDOM, context, isSVG, nextNode, lifecycle) {\n    var shouldUpdate = true;\n    var nextProps = nextVNode.props || EMPTY_OBJ;\n    var nextRef = nextVNode.ref;\n    var lastProps = lastVNode.props;\n    var nextHooksDefined = !isNullOrUndef(nextRef);\n    var lastInput = lastVNode.children;\n    if (nextHooksDefined && isFunction(nextRef.onComponentShouldUpdate)) {\n        shouldUpdate = nextRef.onComponentShouldUpdate(lastProps, nextProps);\n    }\n    if (shouldUpdate !== false) {\n        if (nextHooksDefined && isFunction(nextRef.onComponentWillUpdate)) {\n            nextRef.onComponentWillUpdate(lastProps, nextProps);\n        }\n        var nextInput = normalizeRoot(renderFunctionalComponent(nextVNode, context));\n        patch(lastInput, nextInput, parentDOM, context, isSVG, nextNode, lifecycle);\n        nextVNode.children = nextInput;\n        if (nextHooksDefined && isFunction(nextRef.onComponentDidUpdate)) {\n            nextRef.onComponentDidUpdate(lastProps, nextProps);\n        }\n    }\n    else {\n        nextVNode.children = lastInput;\n    }\n}\nfunction patchText(lastVNode, nextVNode) {\n    var nextText = nextVNode.children;\n    var dom = (nextVNode.dom = lastVNode.dom);\n    if (nextText !== lastVNode.children) {\n        dom.nodeValue = nextText;\n    }\n}\nfunction patchNonKeyedChildren(lastChildren, nextChildren, dom, context, isSVG, lastChildrenLength, nextChildrenLength, nextNode, lifecycle) {\n    var commonLength = lastChildrenLength > nextChildrenLength ? nextChildrenLength : lastChildrenLength;\n    var i = 0;\n    var nextChild;\n    var lastChild;\n    for (; i < commonLength; ++i) {\n        nextChild = nextChildren[i];\n        lastChild = lastChildren[i];\n        if (nextChild.flags & 16384 /* InUse */) {\n            nextChild = nextChildren[i] = directClone(nextChild);\n        }\n        patch(lastChild, nextChild, dom, context, isSVG, nextNode, lifecycle);\n        lastChildren[i] = nextChild;\n    }\n    if (lastChildrenLength < nextChildrenLength) {\n        for (i = commonLength; i < nextChildrenLength; ++i) {\n            nextChild = nextChildren[i];\n            if (nextChild.flags & 16384 /* InUse */) {\n                nextChild = nextChildren[i] = directClone(nextChild);\n            }\n            mount(nextChild, dom, context, isSVG, nextNode, lifecycle);\n        }\n    }\n    else if (lastChildrenLength > nextChildrenLength) {\n        for (i = commonLength; i < lastChildrenLength; ++i) {\n            remove(lastChildren[i], dom);\n        }\n    }\n}\nfunction patchKeyedChildren(a, b, dom, context, isSVG, aLength, bLength, outerEdge, parentVNode, lifecycle) {\n    var aEnd = aLength - 1;\n    var bEnd = bLength - 1;\n    var j = 0;\n    var aNode = a[j];\n    var bNode = b[j];\n    var nextPos;\n    var nextNode;\n    // Step 1\n    // tslint:disable-next-line\n    outer: {\n        // Sync nodes with the same key at the beginning.\n        while (aNode.key === bNode.key) {\n            if (bNode.flags & 16384 /* InUse */) {\n                b[j] = bNode = directClone(bNode);\n            }\n            patch(aNode, bNode, dom, context, isSVG, outerEdge, lifecycle);\n            a[j] = bNode;\n            ++j;\n            if (j > aEnd || j > bEnd) {\n                break outer;\n            }\n            aNode = a[j];\n            bNode = b[j];\n        }\n        aNode = a[aEnd];\n        bNode = b[bEnd];\n        // Sync nodes with the same key at the end.\n        while (aNode.key === bNode.key) {\n            if (bNode.flags & 16384 /* InUse */) {\n                b[bEnd] = bNode = directClone(bNode);\n            }\n            patch(aNode, bNode, dom, context, isSVG, outerEdge, lifecycle);\n            a[aEnd] = bNode;\n            aEnd--;\n            bEnd--;\n            if (j > aEnd || j > bEnd) {\n                break outer;\n            }\n            aNode = a[aEnd];\n            bNode = b[bEnd];\n        }\n    }\n    if (j > aEnd) {\n        if (j <= bEnd) {\n            nextPos = bEnd + 1;\n            nextNode = nextPos < bLength ? findDOMfromVNode(b[nextPos], true) : outerEdge;\n            while (j <= bEnd) {\n                bNode = b[j];\n                if (bNode.flags & 16384 /* InUse */) {\n                    b[j] = bNode = directClone(bNode);\n                }\n                ++j;\n                mount(bNode, dom, context, isSVG, nextNode, lifecycle);\n            }\n        }\n    }\n    else if (j > bEnd) {\n        while (j <= aEnd) {\n            remove(a[j++], dom);\n        }\n    }\n    else {\n        patchKeyedChildrenComplex(a, b, context, aLength, bLength, aEnd, bEnd, j, dom, isSVG, outerEdge, parentVNode, lifecycle);\n    }\n}\nfunction patchKeyedChildrenComplex(a, b, context, aLength, bLength, aEnd, bEnd, j, dom, isSVG, outerEdge, parentVNode, lifecycle) {\n    var aNode;\n    var bNode;\n    var nextPos;\n    var i = 0;\n    var aStart = j;\n    var bStart = j;\n    var aLeft = aEnd - j + 1;\n    var bLeft = bEnd - j + 1;\n    var sources = new Int32Array(bLeft + 1);\n    // Keep track if its possible to remove whole DOM using textContent = '';\n    var canRemoveWholeContent = aLeft === aLength;\n    var moved = false;\n    var pos = 0;\n    var patched = 0;\n    // When sizes are small, just loop them through\n    if (bLength < 4 || (aLeft | bLeft) < 32) {\n        for (i = aStart; i <= aEnd; ++i) {\n            aNode = a[i];\n            if (patched < bLeft) {\n                for (j = bStart; j <= bEnd; j++) {\n                    bNode = b[j];\n                    if (aNode.key === bNode.key) {\n                        sources[j - bStart] = i + 1;\n                        if (canRemoveWholeContent) {\n                            canRemoveWholeContent = false;\n                            while (aStart < i) {\n                                remove(a[aStart++], dom);\n                            }\n                        }\n                        if (pos > j) {\n                            moved = true;\n                        }\n                        else {\n                            pos = j;\n                        }\n                        if (bNode.flags & 16384 /* InUse */) {\n                            b[j] = bNode = directClone(bNode);\n                        }\n                        patch(aNode, bNode, dom, context, isSVG, outerEdge, lifecycle);\n                        ++patched;\n                        break;\n                    }\n                }\n                if (!canRemoveWholeContent && j > bEnd) {\n                    remove(aNode, dom);\n                }\n            }\n            else if (!canRemoveWholeContent) {\n                remove(aNode, dom);\n            }\n        }\n    }\n    else {\n        var keyIndex = {};\n        // Map keys by their index\n        for (i = bStart; i <= bEnd; ++i) {\n            keyIndex[b[i].key] = i;\n        }\n        // Try to patch same keys\n        for (i = aStart; i <= aEnd; ++i) {\n            aNode = a[i];\n            if (patched < bLeft) {\n                j = keyIndex[aNode.key];\n                if (j !== void 0) {\n                    if (canRemoveWholeContent) {\n                        canRemoveWholeContent = false;\n                        while (i > aStart) {\n                            remove(a[aStart++], dom);\n                        }\n                    }\n                    sources[j - bStart] = i + 1;\n                    if (pos > j) {\n                        moved = true;\n                    }\n                    else {\n                        pos = j;\n                    }\n                    bNode = b[j];\n                    if (bNode.flags & 16384 /* InUse */) {\n                        b[j] = bNode = directClone(bNode);\n                    }\n                    patch(aNode, bNode, dom, context, isSVG, outerEdge, lifecycle);\n                    ++patched;\n                }\n                else if (!canRemoveWholeContent) {\n                    remove(aNode, dom);\n                }\n            }\n            else if (!canRemoveWholeContent) {\n                remove(aNode, dom);\n            }\n        }\n    }\n    // fast-path: if nothing patched remove all old and add all new\n    if (canRemoveWholeContent) {\n        removeAllChildren(dom, parentVNode, a);\n        mountArrayChildren(b, dom, context, isSVG, outerEdge, lifecycle);\n    }\n    else if (moved) {\n        var seq = lis_algorithm(sources);\n        j = seq.length - 1;\n        for (i = bLeft - 1; i >= 0; i--) {\n            if (sources[i] === 0) {\n                pos = i + bStart;\n                bNode = b[pos];\n                if (bNode.flags & 16384 /* InUse */) {\n                    b[pos] = bNode = directClone(bNode);\n                }\n                nextPos = pos + 1;\n                mount(bNode, dom, context, isSVG, nextPos < bLength ? findDOMfromVNode(b[nextPos], true) : outerEdge, lifecycle);\n            }\n            else if (j < 0 || i !== seq[j]) {\n                pos = i + bStart;\n                bNode = b[pos];\n                nextPos = pos + 1;\n                moveVNodeDOM(bNode, dom, nextPos < bLength ? findDOMfromVNode(b[nextPos], true) : outerEdge);\n            }\n            else {\n                j--;\n            }\n        }\n    }\n    else if (patched !== bLeft) {\n        // when patched count doesn't match b length we need to insert those new ones\n        // loop backwards so we can use insertBefore\n        for (i = bLeft - 1; i >= 0; i--) {\n            if (sources[i] === 0) {\n                pos = i + bStart;\n                bNode = b[pos];\n                if (bNode.flags & 16384 /* InUse */) {\n                    b[pos] = bNode = directClone(bNode);\n                }\n                nextPos = pos + 1;\n                mount(bNode, dom, context, isSVG, nextPos < bLength ? findDOMfromVNode(b[nextPos], true) : outerEdge, lifecycle);\n            }\n        }\n    }\n}\nvar result;\nvar p;\nvar maxLen = 0;\n// https://en.wikipedia.org/wiki/Longest_increasing_subsequence\nfunction lis_algorithm(arr) {\n    var arrI = 0;\n    var i = 0;\n    var j = 0;\n    var k = 0;\n    var u = 0;\n    var v = 0;\n    var c = 0;\n    var len = arr.length;\n    if (len > maxLen) {\n        maxLen = len;\n        result = new Int32Array(len);\n        p = new Int32Array(len);\n    }\n    for (; i < len; ++i) {\n        arrI = arr[i];\n        if (arrI !== 0) {\n            j = result[k];\n            if (arr[j] < arrI) {\n                p[i] = j;\n                result[++k] = i;\n                continue;\n            }\n            u = 0;\n            v = k;\n            while (u < v) {\n                c = (u + v) >> 1;\n                if (arr[result[c]] < arrI) {\n                    u = c + 1;\n                }\n                else {\n                    v = c;\n                }\n            }\n            if (arrI < arr[result[u]]) {\n                if (u > 0) {\n                    p[i] = result[u - 1];\n                }\n                result[u] = i;\n            }\n        }\n    }\n    u = k + 1;\n    var seq = new Int32Array(u);\n    v = result[u - 1];\n    while (u-- > 0) {\n        seq[u] = v;\n        v = p[v];\n        result[u] = 0;\n    }\n    return seq;\n}\n\nvar hasDocumentAvailable = typeof document !== 'undefined';\nif (hasDocumentAvailable) {\n    /*\n     * Defining $EV and $V properties on Node.prototype\n     * fixes v8 \"wrong map\" de-optimization\n     */\n    if (window.Node) {\n        Node.prototype.$EV = null;\n        Node.prototype.$V = null;\n    }\n}\nfunction __render(input, parentDOM, callback, context) {\n    var lifecycle = [];\n    var rootInput = parentDOM.$V;\n    renderCheck.v = true;\n    if (isNullOrUndef(rootInput)) {\n        if (!isNullOrUndef(input)) {\n            if (input.flags & 16384 /* InUse */) {\n                input = directClone(input);\n            }\n            mount(input, parentDOM, context, false, null, lifecycle);\n            parentDOM.$V = input;\n            rootInput = input;\n        }\n    }\n    else {\n        if (isNullOrUndef(input)) {\n            remove(rootInput, parentDOM);\n            parentDOM.$V = null;\n        }\n        else {\n            if (input.flags & 16384 /* InUse */) {\n                input = directClone(input);\n            }\n            patch(rootInput, input, parentDOM, context, false, null, lifecycle);\n            rootInput = parentDOM.$V = input;\n        }\n    }\n    callAll(lifecycle);\n    renderCheck.v = false;\n    if (isFunction(callback)) {\n        callback();\n    }\n    if (isFunction(options.renderComplete)) {\n        options.renderComplete(rootInput, parentDOM);\n    }\n}\nfunction render(input, parentDOM, callback, context) {\n    if ( callback === void 0 ) callback = null;\n    if ( context === void 0 ) context = EMPTY_OBJ;\n\n    __render(input, parentDOM, callback, context);\n}\nfunction createRenderer(parentDOM) {\n    return function renderer(lastInput, nextInput, callback, context) {\n        if (!parentDOM) {\n            parentDOM = lastInput;\n        }\n        render(nextInput, parentDOM, callback, context);\n    };\n}\n\nvar QUEUE = [];\nvar nextTick = typeof Promise !== 'undefined'\n    ? Promise.resolve().then.bind(Promise.resolve())\n    : function (a) {\n        window.setTimeout(a, 0);\n    };\nvar microTaskPending = false;\nfunction queueStateChanges(component, newState, callback, force) {\n    var pending = component.$PS;\n    if (isFunction(newState)) {\n        newState = newState(pending ? combineFrom(component.state, pending) : component.state, component.props, component.context);\n    }\n    if (isNullOrUndef(pending)) {\n        component.$PS = newState;\n    }\n    else {\n        for (var stateKey in newState) {\n            pending[stateKey] = newState[stateKey];\n        }\n    }\n    if (!component.$BR) {\n        if (!renderCheck.v) {\n            if (QUEUE.length === 0) {\n                applyState(component, force);\n                if (isFunction(callback)) {\n                    callback.call(component);\n                }\n                return;\n            }\n        }\n        if (QUEUE.indexOf(component) === -1) {\n            QUEUE.push(component);\n        }\n        if (force) {\n            component.$F = true;\n        }\n        if (!microTaskPending) {\n            microTaskPending = true;\n            nextTick(rerender);\n        }\n        if (isFunction(callback)) {\n            var QU = component.$QU;\n            if (!QU) {\n                QU = component.$QU = [];\n            }\n            QU.push(callback);\n        }\n    }\n    else if (isFunction(callback)) {\n        component.$L.push(callback.bind(component));\n    }\n}\nfunction callSetStateCallbacks(component) {\n    var queue = component.$QU;\n    for (var i = 0; i < queue.length; ++i) {\n        queue[i].call(component);\n    }\n    component.$QU = null;\n}\nfunction rerender() {\n    var component;\n    microTaskPending = false;\n    while ((component = QUEUE.shift())) {\n        if (!component.$UN) {\n            var force = component.$F;\n            component.$F = false;\n            applyState(component, force);\n            if (component.$QU) {\n                callSetStateCallbacks(component);\n            }\n        }\n    }\n}\nfunction applyState(component, force) {\n    if (force || !component.$BR) {\n        var pendingState = component.$PS;\n        component.$PS = null;\n        var lifecycle = [];\n        renderCheck.v = true;\n        updateClassComponent(component, combineFrom(component.state, pendingState), component.props, findDOMfromVNode(component.$LI, true).parentNode, component.context, component.$SVG, force, null, lifecycle);\n        callAll(lifecycle);\n        renderCheck.v = false;\n    }\n    else {\n        component.state = component.$PS;\n        component.$PS = null;\n    }\n}\nvar Component = function Component(props, context) {\n    // Public\n    this.state = null;\n    // Internal properties\n    this.$BR = false; // BLOCK RENDER\n    this.$BS = true; // BLOCK STATE\n    this.$PS = null; // PENDING STATE (PARTIAL or FULL)\n    this.$LI = null; // LAST INPUT\n    this.$UN = false; // UNMOUNTED\n    this.$CX = null; // CHILDCONTEXT\n    this.$QU = null; // QUEUE\n    this.$N = false; // Uses new lifecycle API Flag\n    this.$L = null; // Current lifecycle of this component\n    this.$SVG = false; // Flag to keep track if component is inside SVG tree\n    this.$F = false; // Force update flag\n    this.props = props || EMPTY_OBJ;\n    this.context = context || EMPTY_OBJ; // context should not be mutable\n};\nComponent.prototype.forceUpdate = function forceUpdate (callback) {\n    if (this.$UN) {\n        return;\n    }\n    // Do not allow double render during force update\n    queueStateChanges(this, {}, callback, true);\n};\nComponent.prototype.setState = function setState (newState, callback) {\n    if (this.$UN) {\n        return;\n    }\n    if (!this.$BS) {\n        queueStateChanges(this, newState, callback, false);\n    }\n};\nComponent.prototype.render = function render (_nextProps, _nextState, _nextContext) {\n    return null;\n};\n\nvar version = \"7.4.11\";\n\nexport { Component, EMPTY_OBJ, Fragment, createClassComponentInstance as _CI, normalizeRoot as _HI, mount as _M, mountClassComponentCallbacks as _MCCC, mountElement as _ME, mountFunctionalComponentCallbacks as _MFCC, mountProps as _MP, mountRef as _MR, renderFunctionalComponent as _RFC, __render, createComponentVNode, createFragment, createPortal, createRef, createRenderer, createTextVNode, createVNode, directClone, findDOMfromVNode, forwardRef, getFlagsForElementVnode, linkEvent, normalizeProps, options, render, rerender, version };\n"],"sourceRoot":""}