2017-04-27  Addy Osmani  <addyosmani@gmail.com>

        Speedometer: Add an Inferno TodoMVC implementation

        https://bugs.webkit.org/show_bug.cgi?id=171411

        Reviewed by NOBODY (OOPS!).

        Adds a Inferno implem of TodoMVC to Speedometer

        * Speedometer/resources/todomvc/architecture-examples/inferno/dist/bundle.js: Added.

        (_interopRequireDefault):

        (_classCallCheck):

        (_possibleConstructorReturn):

        (_inherits):

        (App):

        (App.):

        (App.prototype.render):

        (isStatefulComponent):

        (isStringOrNumber):

        (isNullOrUndef):

        (isInvalid):

        (isFunction):

        (isAttrAnEvent):

        (isString):

        (isNumber):

        (isNull):

        (isTrue):

        (isUndefined):

        (isObject):

        (throwError):

        (warning):

        (_normalizeVNodes):

        (normalizeVNodes):

        (normalizeChildren):

        (normalizeProps):

        (normalize):

        (createVNode):

        (createVoidVNode):

        (createTextVNode):

        (isVNode):

        (getIncrementalId):

        (sendToDevTools):

        (rerenderRoots):

        (initDevToolsHooks):

        (Lifecycle):

        (Lifecycle.prototype.addListener):

        (Lifecycle.prototype.trigger):

        (constructDefaults):

        (handleEvent):

        (dispatchEvent):

        (normalizeEventName):

        (get event.stopPropagation):

        (get event):

        (docEvent):

        (attachEventToDocument):

        (isCheckedType):

        (isControlled):

        (onTextInputChange):

        (onCheckboxChange):

        (handleAssociatedRadioInputs):

        (applyValue):

        (updateChildOption):

        (onSelectChange):

        (processSelect):

        (onTextareaInputChange):

        (processTextarea):

        (processElement):

        (unmount):

        (unmountVoidOrText):

        (unmountComponent):

        (unmountElement):

        (unmountChildren):

        (unmountRef):

        (patch):

        (patchElement):

        (patchChildren):

        (patchComponent):

        (patchText):

        (patchVoid):

        (patchNonKeyedChildren):

        (patchKeyedChildren):

        (lis_algorithm):

        (patchProp):

        (patchEvents):

        (patchEvent):

        (patchProps):

        (patchStyle):

        (removeProp):

        (disableRecycling):

        (recycleElement):

        (poolElement):

        (recycleComponent):

        (poolComponent):

        (mount):

        (mountText):

        (mountVoid):

        (mountElement):

        (mountArrayChildren):

        (mountComponent):

        (mountStatefulComponentCallbacks):

        (mountStatelessComponentCallbacks):

        (mountRef):

        (copyPropsTo):

        (createStatefulComponentInstance):

        (replaceLastChildAndUnmount):

        (replaceVNode):

        (createStatelessComponentInput):

        (setTextContent):

        (updateTextContent):

        (appendChild):

        (insertOrAppend):

        (documentCreateElement):

        (replaceWithNewNode):

        (replaceChild):

        (removeChild):

        (removeAllChildren):

        (removeChildren):

        (isKeyed):

        (normaliseChildNodes):

        (hydrateComponent):

        (hydrateElement):

        (hydrateChildren):

        (hydrateText):

        (hydrateVoid):

        (hydrate):

        (hydrateRoot):

        (enableFindDOMNode):

        (findDOMNode):

        (getRoot):

        (setRoot):

        (render):

        (createRenderer.return.renderer):

        (createRenderer):

        (linkEvent):

        (false.testFunc):

        (updateParentComponentVNodes):

        (addToQueue):

        (queueStateChanges):

        (Component.1):

        (Component.1.prototype.render):

        (Component.1.prototype.forceUpdate):

        (Component.1.prototype.setState):

        (Component.1.prototype.componentWillMount):

        (Component.1.prototype.componentDidMount):

        (Component.1.prototype.componentWillUnmount):

        (Component.1.prototype.componentDidUpdate):

        (Component.1.prototype.shouldComponentUpdate):

        (Component.1.prototype.componentWillReceiveProps):

        (Component.1.prototype.componentWillUpdate):

        (Component.1.prototype.getChildContext):

        (Component.1.prototype._updateComponent):

        (filters.exports.filters.all):

        (filters.exports.filters.active):

        (filters.exports.filters.completed):

        (read):

        (assign):

        (isEqual):

        (Head):

        (Foot):

        (Model.Model.this):

        (Model.Model.this.add):

        (Model.Model.this.put):

        (Model.Model.this.del):

        (Model.Model.this.toggle):

        (Model.Model.this.toggleAll):

        (Model.Model.this.clearCompleted):

        (Model):

        (_objectWithoutProperties):

        (Item):

        (handleKeydown):

        (handleBlur):

        (handleInput):

        (Item.prototype.render):

        (_initialiseProps._initialiseProps.this.componentWillReceiveProps):

        (_initialiseProps._initialiseProps.this.shouldComponentUpdate):

        (_initialiseProps._initialiseProps.this.componentWillUpdate):

        (_initialiseProps._initialiseProps.this.componentDidUpdate):

        (_initialiseProps._initialiseProps.this.setText):

        (_initialiseProps):

        * Speedometer/resources/todomvc/architecture-examples/inferno/index.html: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-app-css/index.css: Added.

        (html,):

        (button):

        (body):

        (:focus):

        (.hidden):

        (.todoapp):

        (.todoapp input::-webkit-input-placeholder):

        (.todoapp input::-moz-placeholder):

        (.todoapp input::input-placeholder):

        (.todoapp h1):

        (.new-todo,):

        (.new-todo):

        (.main):

        (label[for='toggle-all']):

        (.toggle-all):

        (.toggle-all:before):

        (.toggle-all:checked:before):

        (.todo-list):

        (.todo-list li):

        (.todo-list li:last-child):

        (.todo-list li.editing):

        (.todo-list li.editing .edit):

        (.todo-list li.editing .view):

        (.todo-list li .toggle):

        (.todo-list li .toggle:after):

        (.todo-list li .toggle:checked:after):

        (.todo-list li label):

        (.todo-list li.completed label):

        (.todo-list li .destroy):

        (.todo-list li .destroy:hover):

        (.todo-list li .destroy:after):

        (.todo-list li:hover .destroy):

        (.todo-list li .edit):

        (.todo-list li.editing:last-child):

        (.footer):

        (.footer:before):

        (.todo-count):

        (.todo-count strong):

        (.filters):

        (.filters li):

        (.filters li a):

        (.filters li a:hover):

        (.filters li a.selected):

        (.clear-completed,):

        (.clear-completed:hover):

        (.info):

        (.info p):

        (.info a):

        (.info a:hover):

        (@media screen and (-webkit-min-device-pixel-ratio:0)):

        (.toggle-all,):

        (@media (max-width: 430px)):

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-app-css/package.json: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-app-css/readme.md: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-common/base.css: Added.

        (hr):

        (.learn a):

        (.learn a:hover):

        (.learn h3,):

        (.learn h3):

        (.learn h4):

        (.learn h5):

        (.learn ul):

        (.learn li):

        (.learn p):

        (#issue-count):

        (.quote):

        (.quote p):

        (.quote p:before):

        (.quote p:after):

        (.quote footer):

        (.quote footer img):

        (.quote footer a):

        (.speech-bubble):

        (.speech-bubble:after):

        (.learn-bar > .learn):

        (@media (min-width: 899px)):

        (.learn-bar):

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-common/base.js: Added.

        (_.defaults):

        (template):

        (escaper._.template):

        (_):

        (location.hostname.string_appeared_here.i.r.i.r):

        (redirect):

        (findRoot):

        (xhr.onload):

        (getFile):

        (Learn):

        (Learn.prototype.append):

        (Learn.prototype.fetchIssueCount):

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-common/package.json: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/node_modules/todomvc-common/readme.md: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/package.json: Added.

        * Speedometer/resources/todomvc/architecture-examples/inferno/src/base.js: Added.

        (export.Head):

        * Speedometer/resources/todomvc/architecture-examples/inferno/src/index.js: Added.

        (App.prototype.componentWillMount):

        (App.prototype.edit):

        (App.prototype.render):

        (App):

        * Speedometer/resources/todomvc/architecture-examples/inferno/src/item.js: Added.

        (export.default.Item.prototype.render):

        (export.default.Item):

        * Speedometer/resources/todomvc/architecture-examples/inferno/src/model.js: Added.

        (export.default.Model.prototype.set get arr):

        (export.default.Model):

        * Speedometer/resources/todomvc/architecture-examples/inferno/src/share.js: Added.

        (export.read):

        (export.assign):

        (export.isEqual):

        * Speedometer/resources/todomvc/architecture-examples/inferno/webpack.config.js: Added.

/******/ (function(modules) { // webpackBootstrap

/******/    // The module cache

/******/    var installedModules = {};

/******/    // The require function

/******/    function __webpack_require__(moduleId) {

/******/        // Check if module is in cache

/******/        if(installedModules[moduleId])

/******/            return installedModules[moduleId].exports;

/******/        // Create a new module (and put it into the cache)

/******/        var module = installedModules[moduleId] = {

/******/            exports: {},

/******/            id: moduleId,

/******/            loaded: false

/******/        };

/******/        // Execute the module function

/******/        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/        // Flag the module as loaded

/******/        module.loaded = true;

/******/        // Return the exports of the module

/******/        return module.exports;

/******/    }

/******/    // expose the modules object (__webpack_modules__)

/******/    __webpack_require__.m = modules;

/******/    // expose the module cache

/******/    __webpack_require__.c = installedModules;

/******/    // __webpack_public_path__

/******/    __webpack_require__.p = "dist";

/******/    // Load entry module and return exports

/******/    return __webpack_require__(0);

/******/ })

/************************************************************************/

/******/ ([

/* 0 */

/***/ function(module, exports, __webpack_require__) {

    'use strict';

    var _inferno = __webpack_require__(1);

    var _inferno2 = _interopRequireDefault(_inferno);

    var _infernoComponent = __webpack_require__(3);

    var _infernoComponent2 = _interopRequireDefault(_infernoComponent);

    var _share = __webpack_require__(5);

    var _base = __webpack_require__(6);

    var _model = __webpack_require__(7);

    var _model2 = _interopRequireDefault(_model);

    var _item = __webpack_require__(8);

    var _item2 = _interopRequireDefault(_item);

    function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

    function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

    function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

    function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }

    var render = _inferno2.default.render;

    var model = new _model2.default();

    var App = function (_Component) {

        _inherits(App, _Component);

        function App() {

            var _temp, _this, _ret;

            _classCallCheck(this, App);

            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {

                args[_key] = arguments[_key];

            }

            return _ret = (_temp = (_this = _possibleConstructorReturn(this, _Component.call.apply(_Component, [this].concat(args))), _this), _this.state = {

                route: (0, _share.read)(),

                todos: model.get()

            }, _this.update = function (arr) {

                return _this.setState({ todos: arr });

            }, _this.componentWillMount = function () {

                window.onhashchange = function () {

                    return _this.setState({ route: (0, _share.read)() });

                };

            }, _this.add = function (e) {

                if (e.which !== _share.ENTER) return;

                var val = e.target.value.trim();

                if (!val) return;

                e.target.value = '';

                _this.update(model.add(val));

            }, _this.edit = function (todo, val) {

                val = val.trim();

                if (val.length) {

                    _this.update(model.put(todo, { title: val, editing: 0 }));

                } else {

                    _this.remove(todo);

                }

            }, _this.focus = function (todo) {

                return _this.update(model.put(todo, { editing: 1 }));

            }, _this.blur = function (todo) {

                return _this.update(model.put(todo, { editing: 0 }));

            }, _this.remove = function (todo) {

                return _this.update(model.del(todo));

            }, _this.toggleOne = function (todo) {

                return _this.update(model.toggle(todo));

            }, _this.toggleAll = function (ev) {

                return _this.update(model.toggleAll(ev.target.checked));

            }, _this.clearCompleted = function () {

                return _this.update(model.clearCompleted());

            }, _temp), _possibleConstructorReturn(_this, _ret);

        }

        App.prototype.render = function render(_, _ref) {

            var _this2 = this;

            var todos = _ref.todos,

                route = _ref.route;

            var num = todos.length;

            var shown = todos.filter(_share.filters[route]);

            var numDone = todos.filter(_share.filters.completed).length;

            var numAct = num - numDone;

            return _inferno2.default.createVNode(2, 'div', null, [_inferno2.default.createVNode(16, _base.Head, {

                'onEnter': this.add

            }), num ? _inferno2.default.createVNode(2, 'section', {

                'className': 'main'

            }, [_inferno2.default.createVNode(512, 'input', {

                'className': 'toggle-all',

                'type': 'checkbox',

                'checked': numAct === 0

            }, null, {

                'onClick': this.toggleAll

            }), _inferno2.default.createVNode(2, 'ul', {

                'className': 'todo-list'

            }, shown.map(function (t) {

                return _inferno2.default.createVNode(16, _item2.default, {

                    'data': t,

                    'onBlur': function onBlur() {

                        return _this2.blur(t);

                    },

                    'onFocus': function onFocus() {

                        return _this2.focus(t);

                    },

                    'doDelete': function doDelete() {

                        return _this2.remove(t);

                    },

                    'doSave': function doSave(val) {

                        return _this2.edit(t, val);

                    },

                    'doToggle': function doToggle() {

                        return _this2.toggleOne(t);

                    }

                });

            }))]) : null, numAct || numDone ? _inferno2.default.createVNode(16, _base.Foot, {

                'onClear': this.clearCompleted,

                'left': numAct,

                'done': numDone,

                'route': route

            }) : null]);

        };

        return App;

    }(_infernoComponent2.default);

    render(_inferno2.default.createVNode(16, App), document.getElementById('app'));

/***/ },

/* 1 */

/***/ function(module, exports, __webpack_require__) {

    module.exports = __webpack_require__(2);

/***/ },

/* 2 */

/***/ function(module, exports, __webpack_require__) {

    /*!

     * inferno v1.0.0-beta32

     * (c) 2016 Dominic Gannaway

     * Released under the MIT License.

     */

    (function (global, factory) {

         true ? factory(exports) :

        typeof define === 'function' && define.amd ? define(['exports'], factory) :

        (factory((global.Inferno = global.Inferno || {})));

    }(this, (function (exports) { 'use strict';

    var NO_OP = '$NO_OP';

    var ERROR_MSG = 'a runtime error occured! Use Inferno in development environment to find the error.';

    var isBrowser = typeof window !== 'undefined' && window.document;

    // this is MUCH faster than .constructor === Array and instanceof Array

    // in Node 7 and the later versions of V8, slower in older versions though

    var isArray = Array.isArray;

    function isStatefulComponent(o) {

        return !isUndefined(o.prototype) && !isUndefined(o.prototype.render);

    }

    function isStringOrNumber(obj) {

        return isString(obj) || isNumber(obj);

    }

    function isNullOrUndef(obj) {

        return isUndefined(obj) || isNull(obj);

    }

    function isInvalid(obj) {

        return isNull(obj) || obj === false || isTrue(obj) || isUndefined(obj);

    }

    function isFunction(obj) {

        return typeof obj === 'function';

    }

    function isAttrAnEvent(attr) {

        return attr[0] === 'o' && attr[1] === 'n' && attr.length > 3;

    }

    function isString(obj) {

        return typeof obj === 'string';

    }

    function isNumber(obj) {

        return typeof obj === 'number';

    }

    function isNull(obj) {

        return obj === null;

    }

    function isTrue(obj) {

        return obj === true;

    }

    function isUndefined(obj) {

        return obj === undefined;

    }

    function isObject(o) {

        return typeof o === 'object';

    }

    function throwError(message) {

        if (!message) {

            message = ERROR_MSG;

        }

        throw new Error(("Inferno Error: " + message));

    }

    function warning(condition, message) {

        if (!condition) {

            console.error(message);

        }

    }

    var EMPTY_OBJ = {};

    function cloneVNode(vNodeToClone, props) {

        var _children = [], len = arguments.length - 2;

        while ( len-- > 0 ) _children[ len ] = arguments[ len + 2 ];

        var children = _children;

        if (_children.length > 0 && !isNull(_children[0])) {

            if (!props) {

                props = {};

            }

            if (_children.length === 1) {

                children = _children[0];

            }

            if (isUndefined(props.children)) {

                props.children = children;

            }

            else {

                if (isArray(children)) {

                    if (isArray(props.children)) {

                        props.children = props.children.concat(children);

                    }

                    else {

                        props.children = [props.children].concat(children);

                    }

                }

                else {

                    if (isArray(props.children)) {

                        props.children.push(children);

                    }

                    else {

                        props.children = [props.children];

                        props.children.push(children);

                    }

                }

            }

        }

        children = null;

        var flags = vNodeToClone.flags;

        var events = vNodeToClone.events || (props && props.events) || null;

        var newVNode;

        if (isArray(vNodeToClone)) {

            newVNode = vNodeToClone.map(function (vNode) { return cloneVNode(vNode); });

        }

        else if (isNullOrUndef(props) && isNullOrUndef(children)) {

            newVNode = Object.assign({}, vNodeToClone);

        }

        else {

            var key = !isNullOrUndef(vNodeToClone.key) ? vNodeToClone.key : props.key;

            var ref = vNodeToClone.ref || props.ref;

            if (flags & 28 /* Component */) {

                newVNode = createVNode(flags, vNodeToClone.type, Object.assign({}, vNodeToClone.props, props), null, events, key, ref, true);

            }

            else if (flags & 3970 /* Element */) {

                children = (props && props.children) || vNodeToClone.children;

                newVNode = createVNode(flags, vNodeToClone.type, Object.assign({}, vNodeToClone.props, props), children, events, key, ref, !children);

            }

        }

        if (flags & 28 /* Component */) {

            var newProps = newVNode.props;

            if (newProps) {

                var newChildren = newProps.children;

                // we need to also clone component children that are in props

                // as the children may also have been hoisted

                if (newChildren) {

                    if (isArray(newChildren)) {

                        for (var i = 0; i < newChildren.length; i++) {

                            var child = newChildren[i];

                            if (!isInvalid(child) && isVNode(child)) {

                                newProps.children[i] = cloneVNode(child);

                            }

                        }

                    }

                    else if (isVNode(newChildren)) {

                        newProps.children = cloneVNode(newChildren);

                    }

                }

            }

            newVNode.children = null;

        }

        newVNode.dom = null;

        return newVNode;

    }

    function _normalizeVNodes(nodes, result, i) {

        for (; i < nodes.length; i++) {

            var n = nodes[i];

            if (!isInvalid(n)) {

                if (Array.isArray(n)) {

                    _normalizeVNodes(n, result, 0);

                }

                else {

                    if (isStringOrNumber(n)) {

                        n = createTextVNode(n);

                    }

                    else if (isVNode(n) && n.dom) {

                        n = cloneVNode(n);

                    }

                    result.push(n);

                }

            }

        }

    }

    function normalizeVNodes(nodes) {

        var newNodes;

        // we assign $ which basically means we've flagged this array for future note

        // if it comes back again, we need to clone it, as people are using it

        // in an immutable way

        // tslint:disable

        if (nodes['$']) {

            nodes = nodes.slice();

        }

        else {

            nodes['$'] = true;

        }

        // tslint:enable

        for (var i = 0; i < nodes.length; i++) {

            var n = nodes[i];

            if (isInvalid(n)) {

                if (!newNodes) {

                    newNodes = nodes.slice(0, i);

                }

                newNodes.push(n);

            }

            else if (Array.isArray(n)) {

                var result = (newNodes || nodes).slice(0, i);

                _normalizeVNodes(nodes, result, i);

                return result;

            }

            else if (isStringOrNumber(n)) {

                if (!newNodes) {

                    newNodes = nodes.slice(0, i);

                }

                newNodes.push(createTextVNode(n));

            }

            else if (isVNode(n) && n.dom) {

                if (!newNodes) {

                    newNodes = nodes.slice(0, i);

                }

                newNodes.push(cloneVNode(n));

            }

            else if (newNodes) {

                newNodes.push(cloneVNode(n));

            }

        }

        return newNodes || nodes;

    }

    function normalizeChildren(children) {

        if (isArray(children)) {

            return normalizeVNodes(children);

        }

        else if (isVNode(children) && children.dom) {

            return cloneVNode(children);

        }

        return children;

    }

    function normalizeProps(vNode, props, children) {

        if (!(vNode.flags & 28 /* Component */) && isNullOrUndef(children) && !isNullOrUndef(props.children)) {

            vNode.children = props.children;

        }

        if (props.ref) {

            vNode.ref = props.ref;

        }

        if (props.events) {

            vNode.events = props.events;

        }

        if (!isNullOrUndef(props.key)) {

            vNode.key = props.key;

        }

    }

    function normalize(vNode) {

        var props = vNode.props;

        var children = vNode.children;

        // convert a wrongly created type back to element

        if (isString(vNode.type) && (vNode.flags & 28 /* Component */)) {

            vNode.flags = 3970 /* Element */;

        }

        if (props) {

            normalizeProps(vNode, props, children);

        }

        if (!isInvalid(children)) {

            vNode.children = normalizeChildren(children);

        }

        if (props && !isInvalid(props.children)) {

            props.children = normalizeChildren(props.children);

        }

    }

    function createVNode(flags, type, props, children, events, key, ref, noNormalise) {

        if (flags & 16 /* ComponentUnknown */) {

            flags = isStatefulComponent(type) ? 4 /* ComponentClass */ : 8 /* ComponentFunction */;

        }

        var vNode = {

            children: isUndefined(children) ? null : children,

            dom: null,

            events: events || null,

            flags: flags || 0,

            key: key === undefined ? null : key,

            props: props || null,

            ref: ref || null,

            type: type

        };

        if (!noNormalise) {

            normalize(vNode);

        }

        return vNode;

    }

    function createVoidVNode() {

        return createVNode(4096 /* Void */);

    }

    function createTextVNode(text) {

        return createVNode(1 /* Text */, null, null, text);

    }

    function isVNode(o) {

        return !!o.flags;

    }

    var devToolsStatus = {

        connected: false

    };

    var internalIncrementer = {

        id: 0

    };

    var componentIdMap = new Map();

    function getIncrementalId() {

        return internalIncrementer.id++;

    }

    function sendToDevTools(global, data) {

        var event = new CustomEvent('inferno.client.message', {

            detail: JSON.stringify(data, function (key, val) {

                if (!isNull(val) && !isUndefined(val)) {

                    if (key === '_vComponent' || !isUndefined(val.nodeType)) {

                        return;

                    }

                    else if (isFunction(val)) {

                        return ("$$f:" + (val.name));

                    }

                }

                return val;

            })

        });

        global.dispatchEvent(event);

    }

    function rerenderRoots() {

        for (var i = 0; i < roots.length; i++) {

            var root = roots[i];

            render(root.input, root.dom);

        }

    }

    function initDevToolsHooks(global) {

        global.__INFERNO_DEVTOOLS_GLOBAL_HOOK__ = roots;

        global.addEventListener('inferno.devtools.message', function (message) {

            var detail = JSON.parse(message.detail);

            var type = detail.type;

            switch (type) {

                case 'get-roots':

                    if (!devToolsStatus.connected) {

                        devToolsStatus.connected = true;

                        rerenderRoots();

                        sendRoots(global);

                    }

                    break;

                default:

                    // TODO:?

                    break;

            }

        });

    }

    function sendRoots(global) {

        sendToDevTools(global, { type: 'roots', data: roots });

    }

    var Lifecycle = function Lifecycle() {

        this.listeners = [];

        this.fastUnmount = true;

    };

    Lifecycle.prototype.addListener = function addListener (callback) {

        this.listeners.push(callback);

    };

    Lifecycle.prototype.trigger = function trigger () {

            var this$1 = this;

        for (var i = 0; i < this.listeners.length; i++) {

            this$1.listeners[i]();

        }

    };

    function constructDefaults(string, object, value) {

        /* eslint no-return-assign: 0 */

        string.split(',').forEach(function (i) { return object[i] = value; });

    }

    var xlinkNS = 'http://www.w3.org/1999/xlink';

    var xmlNS = 'http://www.w3.org/XML/1998/namespace';

    var svgNS = 'http://www.w3.org/2000/svg';

    var strictProps = {};

    var booleanProps = {};

    var namespaces = {};

    var isUnitlessNumber = {};

    var skipProps = {};

    var dehyphenProps = {

        textAnchor: 'text-anchor'

    };

    var delegatedProps = {};

    constructDefaults('xlink:href,xlink:arcrole,xlink:actuate,xlink:role,xlink:titlef,xlink:type', namespaces, xlinkNS);

    constructDefaults('xml:base,xml:lang,xml:space', namespaces, xmlNS);

    constructDefaults('volume,defaultValue,defaultChecked', strictProps, true);

    constructDefaults('children,ref,key,selected,checked,value,multiple', skipProps, true);

    constructDefaults('onClick,onMouseDown,onMouseUp,onMouseMove', delegatedProps, true);

    constructDefaults('muted,scoped,loop,open,checked,default,capture,disabled,readonly,required,autoplay,controls,seamless,reversed,allowfullscreen,novalidate', booleanProps, true);

    constructDefaults('animationIterationCount,borderImageOutset,borderImageSlice,borderImageWidth,boxFlex,boxFlexGroup,boxOrdinalGroup,columnCount,flex,flexGrow,flexPositive,flexShrink,flexNegative,flexOrder,gridRow,gridColumn,fontWeight,lineClamp,lineHeight,opacity,order,orphans,tabSize,widows,zIndex,zoom,fillOpacity,floodOpacity,stopOpacity,strokeDasharray,strokeDashoffset,strokeMiterlimit,strokeOpacity,strokeWidth,', isUnitlessNumber, true);

    var delegatedEvents = new Map();

    function handleEvent(name, lastEvent, nextEvent, dom) {

        var delegatedRoots = delegatedEvents.get(name);

        if (nextEvent) {

            if (!delegatedRoots) {

                delegatedRoots = { items: new Map(), count: 0, docEvent: null };

                var docEvent = attachEventToDocument(name, delegatedRoots);

                delegatedRoots.docEvent = docEvent;

                delegatedEvents.set(name, delegatedRoots);

            }

            if (!lastEvent) {

                delegatedRoots.count++;

            }

            delegatedRoots.items.set(dom, nextEvent);

        }

        else if (delegatedRoots) {

            if (delegatedRoots.items.has(dom)) {

                delegatedRoots.count--;

                delegatedRoots.items.delete(dom);

                if (delegatedRoots.count === 0) {

                    document.removeEventListener(normalizeEventName(name), delegatedRoots.docEvent);

                    delegatedEvents.delete(name);

                }

            }

        }

    }

    function dispatchEvent(event, dom, items, count, eventData) {

        var eventsToTrigger = items.get(dom);

        if (eventsToTrigger) {

            count--;

            // linkEvent object

            eventData.dom = dom;

            if (eventsToTrigger.event) {

                eventsToTrigger.event(eventsToTrigger.data, event);

            }

            else {

                eventsToTrigger(event);

            }

            if (eventData.stopPropagation) {

                return;

            }

        }

        var parentDom = dom.parentNode;

        if (count > 0 && (parentDom || parentDom === document.body)) {

            dispatchEvent(event, parentDom, items, count, eventData);

        }

    }

    function normalizeEventName(name) {

        return name.substr(2).toLowerCase();

    }

    function attachEventToDocument(name, delegatedRoots) {

        var docEvent = function (event) {

            var eventData = {

                stopPropagation: false,

                dom: document

            };

            // we have to do this as some browsers recycle the same Event between calls

            // so we need to make the property configurable

            Object.defineProperty(event, 'currentTarget', {

                configurable: true,

                get: function get() {

                    return eventData.dom;

                }

            });

            event.stopPropagation = function () {

                eventData.stopPropagation = true;

            };

            var count = delegatedRoots.count;

            if (count > 0) {

                dispatchEvent(event, event.target, delegatedRoots.items, count, eventData);

            }

        };

        document.addEventListener(normalizeEventName(name), docEvent);

        return docEvent;

    }

    function isCheckedType(type) {

        return type === 'checkbox' || type === 'radio';

    }

    function isControlled(props) {

        var usesChecked = isCheckedType(props.type);

        return usesChecked ? !isNullOrUndef(props.checked) : !isNullOrUndef(props.value);

    }

    function onTextInputChange(e) {

        var vNode = this.vNode;

        var events = vNode.events || EMPTY_OBJ;

        var dom = vNode.dom;

        if (events.onInput) {

            events.onInput(e);

        }

        else if (events.oninput) {

            events.oninput(e);

        }

        // the user may have updated the vNode from the above onInput events

        // so we need to get it from the context of `this` again

        applyValue(this.vNode, dom);

    }

    function onCheckboxChange(e) {

        var vNode = this.vNode;

        var events = vNode.events || EMPTY_OBJ;

        var dom = vNode.dom;

        if (events.onClick) {

            events.onClick(e);

        }

        else if (events.onclick) {

            events.onclick(e);

        }

        // the user may have updated the vNode from the above onClick events

        // so we need to get it from the context of `this` again

        applyValue(this.vNode, dom);

    }

    function handleAssociatedRadioInputs(name) {

        var inputs = document.querySelectorAll(("input[type=\"radio\"][name=\"" + name + "\"]"));

        [].forEach.call(inputs, function (dom) {

            var inputWrapper = wrappers.get(dom);

            if (inputWrapper) {

                var props = inputWrapper.vNode.props;

                if (props) {

                    dom.checked = inputWrapper.vNode.props.checked;

                }

            }

        });

    }

    function processInput(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        applyValue(vNode, dom);

        if (isControlled(props)) {

            var inputWrapper = wrappers.get(dom);

            if (!inputWrapper) {

                inputWrapper = {

                    vNode: vNode

                };

                if (isCheckedType(props.type)) {

                    dom.onclick = onCheckboxChange.bind(inputWrapper);

                    dom.onclick.wrapped = true;

                }

                else {

                    dom.oninput = onTextInputChange.bind(inputWrapper);

                    dom.oninput.wrapped = true;

                }

                wrappers.set(dom, inputWrapper);

            }

            inputWrapper.vNode = vNode;

        }

    }

    function applyValue(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        var type = props.type;

        var value = props.value;

        var checked = props.checked;

        if (type !== dom.type && type) {

            dom.type = type;

        }

        if (props.multiple !== dom.multiple) {

            dom.multiple = props.multiple;

        }

        if (isCheckedType(type)) {

            if (!isNullOrUndef(value)) {

                dom.value = value;

            }

            dom.checked = checked;

            if (type === 'radio' && props.name) {

                handleAssociatedRadioInputs(props.name);

            }

        }

        else {

            if (!isNullOrUndef(value) && dom.value !== value) {

                dom.value = value;

            }

            else if (!isNullOrUndef(checked)) {

                dom.checked = checked;

            }

        }

    }

    function isControlled$1(props) {

        return !isNullOrUndef(props.value);

    }

    function updateChildOption(vNode, value) {

        var props = vNode.props || EMPTY_OBJ;

        var dom = vNode.dom;

        // we do this as multiple may have changed

        dom.value = props.value;

        if ((isArray(value) && value.indexOf(props.value) !== -1) || props.value === value) {

            dom.selected = true;

        }

        else {

            dom.selected = props.selected || false;

        }

    }

    function onSelectChange(e) {

        var vNode = this.vNode;

        var events = vNode.events || EMPTY_OBJ;

        var dom = vNode.dom;

        if (events.onChange) {

            events.onChange(e);

        }

        else if (events.onchange) {

            events.onchange(e);

        }

        // the user may have updated the vNode from the above onChange events

        // so we need to get it from the context of `this` again

        applyValue$1(this.vNode, dom);

    }

    function processSelect(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        applyValue$1(vNode, dom);

        if (isControlled$1(props)) {

            var selectWrapper = wrappers.get(dom);

            if (!selectWrapper) {

                selectWrapper = {

                    vNode: vNode

                };

                dom.onchange = onSelectChange.bind(selectWrapper);

                dom.onchange.wrapped = true;

                wrappers.set(dom, selectWrapper);

            }

            selectWrapper.vNode = vNode;

        }

    }

    function applyValue$1(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        if (props.multiple !== dom.multiple) {

            dom.multiple = props.multiple;

        }

        var children = vNode.children;

        var value = props.value;

        if (isArray(children)) {

            for (var i = 0; i < children.length; i++) {

                updateChildOption(children[i], value);

            }

        }

        else if (isVNode(children)) {

            updateChildOption(children, value);

        }

    }

    function isControlled$2(props) {

        return !isNullOrUndef(props.value);

    }

    function onTextareaInputChange(e) {

        var vNode = this.vNode;

        var events = vNode.events || EMPTY_OBJ;

        var dom = vNode.dom;

        if (events.onInput) {

            events.onInput(e);

        }

        else if (events.oninput) {

            events.oninput(e);

        }

        // the user may have updated the vNode from the above onInput events

        // so we need to get it from the context of `this` again

        applyValue$2(this.vNode, dom);

    }

    function processTextarea(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        applyValue$2(vNode, dom);

        var textareaWrapper = wrappers.get(dom);

        if (isControlled$2(props)) {

            if (!textareaWrapper) {

                textareaWrapper = {

                    vNode: vNode

                };

                dom.oninput = onTextareaInputChange.bind(textareaWrapper);

                dom.oninput.wrapped = true;

                wrappers.set(dom, textareaWrapper);

            }

            textareaWrapper.vNode = vNode;

        }

    }

    function applyValue$2(vNode, dom) {

        var props = vNode.props || EMPTY_OBJ;

        var value = props.value;

        if (dom.value !== value) {

            dom.value = value;

        }

    }

    var wrappers = new Map();

    function processElement(flags, vNode, dom) {

        if (flags & 512 /* InputElement */) {

            processInput(vNode, dom);

        }

        else if (flags & 2048 /* SelectElement */) {

            processSelect(vNode, dom);

        }

        else if (flags & 1024 /* TextareaElement */) {

            processTextarea(vNode, dom);

        }

    }

    function unmount(vNode, parentDom, lifecycle, canRecycle, shallowUnmount, isRecycling) {

        var flags = vNode.flags;

        if (flags & 28 /* Component */) {

            unmountComponent(vNode, parentDom, lifecycle, canRecycle, shallowUnmount, isRecycling);

        }

        else if (flags & 3970 /* Element */) {

            unmountElement(vNode, parentDom, lifecycle, canRecycle, shallowUnmount, isRecycling);

        }

        else if (flags & (1 /* Text */ | 4096 /* Void */)) {

            unmountVoidOrText(vNode, parentDom);

        }

    }

    function unmountVoidOrText(vNode, parentDom) {

        if (parentDom) {

            removeChild(parentDom, vNode.dom);

        }

    }

    function unmountComponent(vNode, parentDom, lifecycle, canRecycle, shallowUnmount, isRecycling) {

        var instance = vNode.children;

        var flags = vNode.flags;

        var isStatefulComponent$$1 = flags & 4;

        var ref = vNode.ref;

        var dom = vNode.dom;

        if (!isRecycling) {

            if (!shallowUnmount) {

                if (isStatefulComponent$$1) {

                    var subLifecycle = instance._lifecycle;

                    if (!subLifecycle.fastUnmount) {

                        unmount(instance._lastInput, null, lifecycle, false, shallowUnmount, isRecycling);

                    }

                }

                else {

                    if (!lifecycle.fastUnmount) {

                        unmount(instance, null, lifecycle, false, shallowUnmount, isRecycling);

                    }

                }

            }

            if (isStatefulComponent$$1) {

                instance._ignoreSetState = true;

                instance.componentWillUnmount();

                if (ref && !isRecycling) {

                    ref(null);

                }

                instance._unmounted = true;

                findDOMNodeEnabled && componentToDOMNodeMap.delete(instance);

            }

            else if (!isNullOrUndef(ref)) {

                if (!isNullOrUndef(ref.onComponentWillUnmount)) {

                    ref.onComponentWillUnmount(dom);

                }

            }

        }

        if (parentDom) {

            var lastInput = instance._lastInput;

            if (isNullOrUndef(lastInput)) {

                lastInput = instance;

            }

            removeChild(parentDom, dom);

        }

        if (recyclingEnabled && !isStatefulComponent$$1 && (parentDom || canRecycle)) {

            poolComponent(vNode);

        }

    }

    function unmountElement(vNode, parentDom, lifecycle, canRecycle, shallowUnmount, isRecycling) {

        var dom = vNode.dom;

        var ref = vNode.ref;

        var events = vNode.events;

        if (!shallowUnmount && !lifecycle.fastUnmount) {

            if (ref && !isRecycling) {

                unmountRef(ref);

            }

            var children = vNode.children;

            if (!isNullOrUndef(children)) {

                unmountChildren$1(children, lifecycle, shallowUnmount, isRecycling);

            }

        }

        if (!isNull(events)) {

            for (var name in events) {

                // do not add a hasOwnProperty check here, it affects performance

                patchEvent(name, events[name], null, dom, lifecycle);

                events[name] = null;

            }

        }

        if (parentDom) {

            removeChild(parentDom, dom);

        }

        if (recyclingEnabled && (parentDom || canRecycle)) {

            poolElement(vNode);

        }

    }

    function unmountChildren$1(children, lifecycle, shallowUnmount, isRecycling) {

        if (isArray(children)) {

            for (var i = 0; i < children.length; i++) {

                var child = children[i];

                if (!isInvalid(child) && isObject(child)) {

                    unmount(child, null, lifecycle, false, shallowUnmount, isRecycling);

                }

            }

        }

        else if (isObject(children)) {

            unmount(children, null, lifecycle, false, shallowUnmount, isRecycling);

        }

    }

    function unmountRef(ref) {

        if (isFunction(ref)) {

            ref(null);

        }

        else {

            if (isInvalid(ref)) {

                return;

            }

            if (false) {

                throwError('string "refs" are not supported in Inferno 1.0. Use callback "refs" instead.');

            }

            throwError();

        }

    }

    function patch(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling) {

        if (lastVNode !== nextVNode) {

            var lastFlags = lastVNode.flags;

            var nextFlags = nextVNode.flags;

            if (nextFlags & 28 /* Component */) {

                if (lastFlags & 28 /* Component */) {

                    patchComponent(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, nextFlags & 4 /* ComponentClass */, isRecycling);

                }

                else {

                    replaceVNode(parentDom, mountComponent(nextVNode, null, lifecycle, context, isSVG, nextFlags & 4 /* ComponentClass */), lastVNode, lifecycle, isRecycling);

                }

            }

            else if (nextFlags & 3970 /* Element */) {

                if (lastFlags & 3970 /* Element */) {

                    patchElement(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling);

                }

                else {

                    replaceVNode(parentDom, mountElement(nextVNode, null, lifecycle, context, isSVG), lastVNode, lifecycle, isRecycling);

                }

            }

            else if (nextFlags & 1 /* Text */) {

                if (lastFlags & 1 /* Text */) {

                    patchText(lastVNode, nextVNode);

                }

                else {

                    replaceVNode(parentDom, mountText(nextVNode, null), lastVNode, lifecycle, isRecycling);

                }

            }

            else if (nextFlags & 4096 /* Void */) {

                if (lastFlags & 4096 /* Void */) {

                    patchVoid(lastVNode, nextVNode);

                }

                else {

                    replaceVNode(parentDom, mountVoid(nextVNode, null), lastVNode, lifecycle, isRecycling);

                }

            }

            else {

                // Error case: mount new one replacing old one

                replaceLastChildAndUnmount(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling);

            }

        }

    }

    function unmountChildren(children, dom, lifecycle, isRecycling) {

        if (isVNode(children)) {

            unmount(children, dom, lifecycle, true, false, isRecycling);

        }

        else if (isArray(children)) {

            removeAllChildren(dom, children, lifecycle, false, isRecycling);

        }

        else {

            dom.textContent = '';

        }

    }

    function patchElement(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling) {

        var nextTag = nextVNode.type;

        var lastTag = lastVNode.type;

        if (lastTag !== nextTag) {

            replaceWithNewNode(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling);

        }

        else {

            var dom = lastVNode.dom;

            var lastProps = lastVNode.props;

            var nextProps = nextVNode.props;

            var lastChildren = lastVNode.children;

            var nextChildren = nextVNode.children;

            var lastFlags = lastVNode.flags;

            var nextFlags = nextVNode.flags;

            var lastRef = lastVNode.ref;

            var nextRef = nextVNode.ref;

            var lastEvents = lastVNode.events;

            var nextEvents = nextVNode.events;

            nextVNode.dom = dom;

            if (isSVG || (nextFlags & 128 /* SvgElement */)) {

                isSVG = true;

            }

            if (lastChildren !== nextChildren) {

                patchChildren(lastFlags, nextFlags, lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling);

            }

            if (!(nextFlags & 2 /* HtmlElement */)) {

                processElement(nextFlags, nextVNode, dom);

            }

            if (lastProps !== nextProps) {

                patchProps(lastProps, nextProps, dom, lifecycle, context, isSVG);

            }

            if (lastEvents !== nextEvents) {

                patchEvents(lastEvents, nextEvents, dom, lifecycle);

            }

            if (nextRef) {

                if (lastRef !== nextRef || isRecycling) {

                    mountRef(dom, nextRef, lifecycle);

                }

            }

        }

    }

    function patchChildren(lastFlags, nextFlags, lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling) {

        var patchArray = false;

        var patchKeyed = false;

        if (nextFlags & 64 /* HasNonKeyedChildren */) {

            patchArray = true;

        }

        else if ((lastFlags & 32 /* HasKeyedChildren */) && (nextFlags & 32 /* HasKeyedChildren */)) {

            patchKeyed = true;

            patchArray = true;

        }

        else if (isInvalid(nextChildren)) {

            unmountChildren(lastChildren, dom, lifecycle, isRecycling);

        }

        else if (isInvalid(lastChildren)) {

            if (isStringOrNumber(nextChildren)) {

                setTextContent(dom, nextChildren);

            }

            else {

                if (isArray(nextChildren)) {

                    mountArrayChildren(nextChildren, dom, lifecycle, context, isSVG);

                }

                else {

                    mount(nextChildren, dom, lifecycle, context, isSVG);

                }

            }

        }

        else if (isStringOrNumber(nextChildren)) {

            if (isStringOrNumber(lastChildren)) {

                updateTextContent(dom, nextChildren);

            }

            else {

                unmountChildren(lastChildren, dom, lifecycle, isRecycling);

                setTextContent(dom, nextChildren);

            }

        }

        else if (isArray(nextChildren)) {

            if (isArray(lastChildren)) {

                patchArray = true;

                if (isKeyed(lastChildren, nextChildren)) {

                    patchKeyed = true;

                }

            }

            else {

                unmountChildren(lastChildren, dom, lifecycle, isRecycling);

                mountArrayChildren(nextChildren, dom, lifecycle, context, isSVG);

            }

        }

        else if (isArray(lastChildren)) {

            removeAllChildren(dom, lastChildren, lifecycle, false, isRecycling);

            mount(nextChildren, dom, lifecycle, context, isSVG);

        }

        else if (isVNode(nextChildren)) {

            if (isVNode(lastChildren)) {

                patch(lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling);

            }

            else {

                unmountChildren(lastChildren, dom, lifecycle, isRecycling);

                mount(nextChildren, dom, lifecycle, context, isSVG);

            }

        }

        else if (isVNode(lastChildren)) {

        }

        else {

        }

        if (patchArray) {

            if (patchKeyed) {

                patchKeyedChildren(lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling);

            }

            else {

                patchNonKeyedChildren(lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling);

            }

        }

    }

    function patchComponent(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isClass, isRecycling) {

        var lastType = lastVNode.type;

        var nextType = nextVNode.type;

        var nextProps = nextVNode.props || EMPTY_OBJ;

        var lastKey = lastVNode.key;

        var nextKey = nextVNode.key;

        if (lastType !== nextType) {

            if (isClass) {

                replaceWithNewNode(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling);

            }

            else {

                var lastInput = lastVNode.children._lastInput || lastVNode.children;

                var nextInput = createStatelessComponentInput(nextVNode, nextType, nextProps, context);

                patch(lastInput, nextInput, parentDom, lifecycle, context, isSVG, isRecycling);

                var dom = nextVNode.dom = nextInput.dom;

                nextVNode.children = nextInput;

                mountStatelessComponentCallbacks(nextVNode.ref, dom, lifecycle);

                unmount(lastVNode, null, lifecycle, false, true, isRecycling);

            }

        }

        else {

            if (isClass) {

                if (lastKey !== nextKey) {

                    replaceWithNewNode(lastVNode, nextVNode, parentDom, lifecycle, context, isSVG, isRecycling);

                    return false;

                }

                var instance = lastVNode.children;

                if (instance._unmounted) {

                    if (isNull(parentDom)) {

                        return true;

                    }

                    replaceChild(parentDom, mountComponent(nextVNode, null, lifecycle, context, isSVG, nextVNode.flags & 4 /* ComponentClass */), lastVNode.dom);

                }

                else {

                    var defaultProps = nextType.defaultProps;

                    var lastProps = instance.props;

                    if (instance._devToolsStatus.connected && !instance._devToolsId) {

                        componentIdMap.set(instance._devToolsId = getIncrementalId(), instance);

                    }

                    lifecycle.fastUnmount = false;

                    if (!isUndefined(defaultProps)) {

                        copyPropsTo(lastProps, nextProps);

                        nextVNode.props = nextProps;

                    }

                    var lastState = instance.state;

                    var nextState = instance.state;

                    var childContext = instance.getChildContext();

                    nextVNode.children = instance;

                    instance._isSVG = isSVG;

                    if (!isNullOrUndef(childContext)) {

                        childContext = Object.assign({}, context, childContext);

                    }

                    else {

                        childContext = context;

                    }

                    var lastInput$1 = instance._lastInput;

                    var nextInput$1 = instance._updateComponent(lastState, nextState, lastProps, nextProps, context, false);

                    var didUpdate = true;

                    instance._childContext = childContext;

                    if (isInvalid(nextInput$1)) {

                        nextInput$1 = createVoidVNode();

                    }

                    else if (isArray(nextInput$1)) {

                        if (false) {

                            throwError('a valid Inferno VNode (or null) must be returned from a component render. You may have returned an array or an invalid object.');

                        }

                        throwError();

                    }

                    else if (nextInput$1 === NO_OP) {

                        nextInput$1 = lastInput$1;

                        didUpdate = false;

                    }

                    else if (isObject(nextInput$1) && nextInput$1.dom) {

                        nextInput$1 = cloneVNode(nextInput$1);

                    }

                    if (nextInput$1.flags & 28 /* Component */) {

                        nextInput$1.parentVNode = nextVNode;

                    }

                    else if (lastInput$1.flags & 28 /* Component */) {

                        lastInput$1.parentVNode = nextVNode;

                    }

                    instance._lastInput = nextInput$1;

                    instance._vNode = nextVNode;

                    if (didUpdate) {

                        var fastUnmount = lifecycle.fastUnmount;

                        var subLifecycle = instance._lifecycle;

                        lifecycle.fastUnmount = subLifecycle.fastUnmount;

                        patch(lastInput$1, nextInput$1, parentDom, lifecycle, childContext, isSVG, isRecycling);

                        subLifecycle.fastUnmount = lifecycle.unmount;

                        lifecycle.fastUnmount = fastUnmount;

                        instance.componentDidUpdate(lastProps, lastState);

                        findDOMNodeEnabled && componentToDOMNodeMap.set(instance, nextInput$1.dom);

                    }

                    nextVNode.dom = nextInput$1.dom;

                }

            }

            else {

                var shouldUpdate = true;

                var lastProps$1 = lastVNode.props;

                var nextHooks = nextVNode.ref;

                var nextHooksDefined = !isNullOrUndef(nextHooks);

                var lastInput$2 = lastVNode.children;

                var nextInput$2 = lastInput$2;

                nextVNode.dom = lastVNode.dom;

                nextVNode.children = lastInput$2;

                if (lastKey !== nextKey) {

                    shouldUpdate = true;

                }

                else {

                    if (nextHooksDefined && !isNullOrUndef(nextHooks.onComponentShouldUpdate)) {

                        shouldUpdate = nextHooks.onComponentShouldUpdate(lastProps$1, nextProps);

                    }

                }

                if (shouldUpdate !== false) {

                    if (nextHooksDefined && !isNullOrUndef(nextHooks.onComponentWillUpdate)) {

                        lifecycle.fastUnmount = false;

                        nextHooks.onComponentWillUpdate(lastProps$1, nextProps);

                    }

                    nextInput$2 = nextType(nextProps, context);

                    if (isInvalid(nextInput$2)) {

                        nextInput$2 = createVoidVNode();

                    }

                    else if (isArray(nextInput$2)) {

                        if (false) {

                            throwError('a valid Inferno VNode (or null) must be returned from a component render. You may have returned an array or an invalid object.');

                        }

                        throwError();

                    }

                    else if (isObject(nextInput$2) && nextInput$2.dom) {

                        nextInput$2 = cloneVNode(nextInput$2);

                    }

                    if (nextInput$2 !== NO_OP) {

                        patch(lastInput$2, nextInput$2, parentDom, lifecycle, context, isSVG, isRecycling);

                        nextVNode.children = nextInput$2;

                        if (nextHooksDefined && !isNullOrUndef(nextHooks.onComponentDidUpdate)) {

                            lifecycle.fastUnmount = false;

                            nextHooks.onComponentDidUpdate(lastProps$1, nextProps);

                        }

                        nextVNode.dom = nextInput$2.dom;

                    }

                }

                if (nextInput$2.flags & 28 /* Component */) {

                    nextInput$2.parentVNode = nextVNode;

                }

                else if (lastInput$2.flags & 28 /* Component */) {

                    lastInput$2.parentVNode = nextVNode;

                }

            }

        }

        return false;

    }

    function patchText(lastVNode, nextVNode) {

        var nextText = nextVNode.children;

        var dom = lastVNode.dom;

        nextVNode.dom = dom;

        if (lastVNode.children !== nextText) {

            dom.nodeValue = nextText;

        }

    }

    function patchVoid(lastVNode, nextVNode) {

        nextVNode.dom = lastVNode.dom;

    }

    function patchNonKeyedChildren(lastChildren, nextChildren, dom, lifecycle, context, isSVG, isRecycling) {

        var lastChildrenLength = lastChildren.length;

        var nextChildrenLength = nextChildren.length;

        var commonLength = lastChildrenLength > nextChildrenLength ? nextChildrenLength : lastChildrenLength;

        var i;

        var nextNode = null;

        var newNode;

        // Loop backwards so we can use insertBefore

        if (lastChildrenLength < nextChildrenLength) {

            for (i = nextChildrenLength - 1; i >= commonLength; i--) {

                var child = nextChildren[i];

                if (!isInvalid(child)) {

                    if (child.dom) {

                        nextChildren[i] = child = cloneVNode(child);

                    }

                    newNode = mount(child, null, lifecycle, context, isSVG);

                    insertOrAppend(dom, newNode, nextNode);

                    nextNode = newNode;

                }

            }

        }

        else if (nextChildrenLength === 0) {

            removeAllChildren(dom, lastChildren, lifecycle, false, isRecycling);

        }

        else if (lastChildrenLength > nextChildrenLength) {

            for (i = commonLength; i < lastChildrenLength; i++) {

                var child$1 = lastChildren[i];

                if (!isInvalid(child$1)) {

                    unmount(lastChildren[i], dom, lifecycle, false, false, isRecycling);

                }

            }

        }

        for (i = commonLength - 1; i >= 0; i--) {

            var lastChild = lastChildren[i];

            var nextChild = nextChildren[i];

            if (isInvalid(nextChild)) {

                if (!isInvalid(lastChild)) {

                    unmount(lastChild, dom, lifecycle, true, false, isRecycling);

                }

            }

            else {

                if (nextChild.dom) {

                    nextChildren[i] = nextChild = cloneVNode(nextChild);

                }

                if (isInvalid(lastChild)) {

                    newNode = mount(nextChild, null, lifecycle, context, isSVG);

                    insertOrAppend(dom, newNode, nextNode);

                    nextNode = newNode;

                }

                else {

                    patch(lastChild, nextChild, dom, lifecycle, context, isSVG, isRecycling);

                    nextNode = nextChild.dom;

                }

            }

        }

    }

    function patchKeyedChildren(a, b, dom, lifecycle, context, isSVG, isRecycling) {

        var aLength = a.length;

        var bLength = b.length;

        var aEnd = aLength - 1;

        var bEnd = bLength - 1;

        var aStart = 0;

        var bStart = 0;

        var i;

        var j;

        var aNode;

        var bNode;

        var nextNode;

        var nextPos;

        var node;

        if (aLength === 0) {

            if (bLength !== 0) {

                mountArrayChildren(b, dom, lifecycle, context, isSVG);

            }

            return;

        }

        else if (bLength === 0) {

            removeAllChildren(dom, a, lifecycle, false, isRecycling);

            return;

        }

        var aStartNode = a[aStart];

        var bStartNode = b[bStart];

        var aEndNode = a[aEnd];

        var bEndNode = b[bEnd];

        if (bStartNode.dom) {

            b[bStart] = bStartNode = cloneVNode(bStartNode);

        }

        if (bEndNode.dom) {

            b[bEnd] = bEndNode = cloneVNode(bEndNode);

        }

        // Step 1

        /* eslint no-constant-condition: 0 */

        outer: while (true) {

            // Sync nodes with the same key at the beginning.

            while (aStartNode.key === bStartNode.key) {

                patch(aStartNode, bStartNode, dom, lifecycle, context, isSVG, isRecycling);

                aStart++;

                bStart++;

                if (aStart > aEnd || bStart > bEnd) {

                    break outer;

                }

                aStartNode = a[aStart];

                bStartNode = b[bStart];

                if (bStartNode.dom) {

                    b[bStart] = bStartNode = cloneVNode(bStartNode);

                }

            }

            // Sync nodes with the same key at the end.

            while (aEndNode.key === bEndNode.key) {

                patch(aEndNode, bEndNode, dom, lifecycle, context, isSVG, isRecycling);

                aEnd--;

                bEnd--;

                if (aStart > aEnd || bStart > bEnd) {

                    break outer;

                }

                aEndNode = a[aEnd];

                bEndNode = b[bEnd];

                if (bEndNode.dom) {

                    b[bEnd] = bEndNode = cloneVNode(bEndNode);

                }

            }

            // Move and sync nodes from right to left.

            if (aEndNode.key === bStartNode.key) {

                patch(aEndNode, bStartNode, dom, lifecycle, context, isSVG, isRecycling);

                insertOrAppend(dom, bStartNode.dom, aStartNode.dom);

                aEnd--;

                bStart++;

                aEndNode = a[aEnd];

                bStartNode = b[bStart];

                if (bStartNode.dom) {

                    b[bStart] = bStartNode = cloneVNode(bStartNode);

                }

                continue;

            }

            // Move and sync nodes from left to right.

            if (aStartNode.key === bEndNode.key) {

                patch(aStartNode, bEndNode, dom, lifecycle, context, isSVG, isRecycling);

                nextPos = bEnd + 1;

                nextNode = nextPos < b.length ? b[nextPos].dom : null;

                insertOrAppend(dom, bEndNode.dom, nextNode);

                aStart++;

                bEnd--;

                aStartNode = a[aStart];

                bEndNode = b[bEnd];

                if (bEndNode.dom) {

                    b[bEnd] = bEndNode = cloneVNode(bEndNode);

                }

                continue;

            }

            break;

        }

        if (aStart > aEnd) {

            if (bStart <= bEnd) {

                nextPos = bEnd + 1;

                nextNode = nextPos < b.length ? b[nextPos].dom : null;

                while (bStart <= bEnd) {

                    node = b[bStart];

                    if (node.dom) {

                        b[bStart] = node = cloneVNode(node);

                    }

                    bStart++;

                    insertOrAppend(dom, mount(node, null, lifecycle, context, isSVG), nextNode);

                }

            }

        }

        else if (bStart > bEnd) {

            while (aStart <= aEnd) {

                unmount(a[aStart++], dom, lifecycle, false, false, isRecycling);

            }

        }

        else {

            aLength = aEnd - aStart + 1;

            bLength = bEnd - bStart + 1;

            var aNullable = a;

            var sources = new Array(bLength);

            // Mark all nodes as inserted.

            for (i = 0; i < bLength; i++) {

                sources[i] = -1;

            }

            var moved = false;

            var pos = 0;

            var patched = 0;

            if ((bLength <= 4) || (aLength * bLength <= 16)) {

                for (i = aStart; i <= aEnd; i++) {

                    aNode = a[i];

                    if (patched < bLength) {

                        for (j = bStart; j <= bEnd; j++) {

                            bNode = b[j];

                            if (aNode.key === bNode.key) {

                                sources[j - bStart] = i;

                                if (pos > j) {

                                    moved = true;

                                }

                                else {

                                    pos = j;

                                }

                                if (bNode.dom) {

                                    b[j] = bNode = cloneVNode(bNode);

                                }

                                patch(aNode, bNode, dom, lifecycle, context, isSVG, isRecycling);

                                patched++;

                                aNullable[i] = null;

                                break;

                            }

                        }

                    }

                }

            }

            else {

                var keyIndex = new Map();

                for (i = bStart; i <= bEnd; i++) {

                    node = b[i];

                    keyIndex.set(node.key, i);

                }

                for (i = aStart; i <= aEnd; i++) {

                    aNode = a[i];

                    if (patched < bLength) {

                        j = keyIndex.get(aNode.key);

                        if (!isUndefined(j)) {

                            bNode = b[j];

                            sources[j - bStart] = i;

                            if (pos > j) {

                                moved = true;

                            }

                            else {

                                pos = j;

                            }

                            if (bNode.dom) {

                                b[j] = bNode = cloneVNode(bNode);

                            }

                            patch(aNode, bNode, dom, lifecycle, context, isSVG, isRecycling);

                            patched++;

                            aNullable[i] = null;

                        }

                    }

                }

            }

            if (aLength === a.length && patched === 0) {

                removeAllChildren(dom, a, lifecycle, false, isRecycling);

                while (bStart < bLength) {

                    node = b[bStart];

                    if (node.dom) {

                        b[bStart] = node = cloneVNode(node);

                    }

                    bStart++;

                    insertOrAppend(dom, mount(node, null, lifecycle, context, isSVG), null);

                }

            }

            else {

                i = aLength - patched;

                while (i > 0) {

                    aNode = aNullable[aStart++];

                    if (!isNull(aNode)) {

                        unmount(aNode, dom, lifecycle, false, false, isRecycling);

                        i--;

                    }

                }

                if (moved) {

                    var seq = lis_algorithm(sources);

                    j = seq.length - 1;

                    for (i = bLength - 1; i >= 0; i--) {

                        if (sources[i] === -1) {

                            pos = i + bStart;

                            node = b[pos];

                            if (node.dom) {

                                b[pos] = node = cloneVNode(node);

                            }

                            nextPos = pos + 1;

                            nextNode = nextPos < b.length ? b[nextPos].dom : null;

                            insertOrAppend(dom, mount(node, dom, lifecycle, context, isSVG), nextNode);

                        }

                        else {

                            if (j < 0 || i !== seq[j]) {

                                pos = i + bStart;

                                node = b[pos];

                                nextPos = pos + 1;

                                nextNode = nextPos < b.length ? b[nextPos].dom : null;

                                insertOrAppend(dom, node.dom, nextNode);

                            }

                            else {

                                j--;

                            }

                        }

                    }

                }

                else if (patched !== bLength) {

                    for (i = bLength - 1; i >= 0; i--) {

                        if (sources[i] === -1) {

                            pos = i + bStart;

                            node = b[pos];

                            if (node.dom) {

                                b[pos] = node = cloneVNode(node);

                            }

                            nextPos = pos + 1;

                            nextNode = nextPos < b.length ? b[nextPos].dom : null;

                            insertOrAppend(dom, mount(node, null, lifecycle, context, isSVG), nextNode);

                        }

                    }

                }

            }

        }

    }

    // // https://en.wikipedia.org/wiki/Longest_increasing_subsequence

    function lis_algorithm(a) {

        var p = a.slice(0);

        var result = [];

        result.push(0);

        var i;

        var j;

        var u;

        var v;

        var c;

        for (i = 0; i < a.length; i++) {

            if (a[i] === -1) {

                continue;

            }

            j = result[result.length - 1];

            if (a[j] < a[i]) {

                p[i] = j;

                result.push(i);

                continue;

            }

            u = 0;

            v = result.length - 1;

            while (u < v) {

                c = ((u + v) / 2) | 0;

                if (a[result[c]] < a[i]) {

                    u = c + 1;

                }

                else {

                    v = c;

                }

            }

            if (a[i] < a[result[u]]) {

                if (u > 0) {

                    p[i] = result[u - 1];

                }

                result[u] = i;

            }

        }

        u = result.length;

        v = result[u - 1];

        while (u-- > 0) {

            result[u] = v;

            v = p[v];

        }

        return result;

    }

    function patchProp(prop, lastValue, nextValue, dom, isSVG, lifecycle) {

        if (skipProps[prop]) {

            return;

        }

        if (booleanProps[prop]) {

            dom[prop] = nextValue ? true : false;

        }

        else if (strictProps[prop]) {

            var value = isNullOrUndef(nextValue) ? '' : nextValue;

            if (dom[prop] !== value) {

                dom[prop] = value;

            }

        }

        else if (isAttrAnEvent(prop)) {

            patchEvent(prop, lastValue, nextValue, dom, lifecycle);

        }

        else if (lastValue !== nextValue) {

            if (isNullOrUndef(nextValue)) {

                dom.removeAttribute(prop);

            }

            else if (prop === 'className') {

                if (isSVG) {

                    dom.setAttribute('class', nextValue);

                }

                else {

                    dom.className = nextValue;

                }

            }

            else if (prop === 'style') {

                patchStyle(lastValue, nextValue, dom);