{"dependencies":[{"name":"react","loc":{"line":18,"column":20}},{"name":"fbjs/lib/invariant","loc":{"line":19,"column":24}},{"name":"fbjs/lib/warning","loc":{"line":20,"column":22}},{"name":"fbjs/lib/ExecutionEnvironment","loc":{"line":21,"column":35}},{"name":"object-assign","loc":{"line":22,"column":22}},{"name":"fbjs/lib/emptyFunction","loc":{"line":23,"column":28}},{"name":"fbjs/lib/EventListener","loc":{"line":24,"column":28}},{"name":"fbjs/lib/getActiveElement","loc":{"line":25,"column":31}},{"name":"fbjs/lib/shallowEqual","loc":{"line":26,"column":27}},{"name":"fbjs/lib/containsNode","loc":{"line":27,"column":27}},{"name":"fbjs/lib/focusNode","loc":{"line":28,"column":24}},{"name":"fbjs/lib/emptyObject","loc":{"line":29,"column":26}},{"name":"prop-types/checkPropTypes","loc":{"line":30,"column":29}},{"name":"fbjs/lib/hyphenateStyleName","loc":{"line":31,"column":33}},{"name":"fbjs/lib/camelizeStyleName","loc":{"line":32,"column":32}}],"generated":{"js":"/** @license React v16.2.0\n * react-dom.development.js\n *\n * Copyright (c) 2013-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\nif (\"development\" !== \"production\") {\n  (function () {\n    'use strict';\n\n    var React = require('react');\n    var invariant = require('fbjs/lib/invariant');\n    var warning = require('fbjs/lib/warning');\n    var ExecutionEnvironment = require('fbjs/lib/ExecutionEnvironment');\n    var _assign = require('object-assign');\n    var emptyFunction = require('fbjs/lib/emptyFunction');\n    var EventListener = require('fbjs/lib/EventListener');\n    var getActiveElement = require('fbjs/lib/getActiveElement');\n    var shallowEqual = require('fbjs/lib/shallowEqual');\n    var containsNode = require('fbjs/lib/containsNode');\n    var focusNode = require('fbjs/lib/focusNode');\n    var emptyObject = require('fbjs/lib/emptyObject');\n    var checkPropTypes = require('prop-types/checkPropTypes');\n    var hyphenateStyleName = require('fbjs/lib/hyphenateStyleName');\n    var camelizeStyleName = require('fbjs/lib/camelizeStyleName');\n\n    /**\n     * WARNING: DO NOT manually require this module.\n     * This is a replacement for `invariant(...)` used by the error code system\n     * and will _only_ be required by the corresponding babel pass.\n     * It always throws.\n     */\n\n    !React ? invariant(false, 'ReactDOM was loaded before React. Make sure you load the React package before loading ReactDOM.') : void 0;\n\n    // These attributes should be all lowercase to allow for\n    // case insensitive checks\n    var RESERVED_PROPS = {\n      children: true,\n      dangerouslySetInnerHTML: true,\n      defaultValue: true,\n      defaultChecked: true,\n      innerHTML: true,\n      suppressContentEditableWarning: true,\n      suppressHydrationWarning: true,\n      style: true\n    };\n\n    function checkMask(value, bitmask) {\n      return (value & bitmask) === bitmask;\n    }\n\n    var DOMPropertyInjection = {\n      /**\n       * Mapping from normalized, camelcased property names to a configuration that\n       * specifies how the associated DOM property should be accessed or rendered.\n       */\n      MUST_USE_PROPERTY: 0x1,\n      HAS_BOOLEAN_VALUE: 0x4,\n      HAS_NUMERIC_VALUE: 0x8,\n      HAS_POSITIVE_NUMERIC_VALUE: 0x10 | 0x8,\n      HAS_OVERLOADED_BOOLEAN_VALUE: 0x20,\n      HAS_STRING_BOOLEAN_VALUE: 0x40,\n\n      /**\n       * Inject some specialized knowledge about the DOM. This takes a config object\n       * with the following properties:\n       *\n       * Properties: object mapping DOM property name to one of the\n       * DOMPropertyInjection constants or null. If your attribute isn't in here,\n       * it won't get written to the DOM.\n       *\n       * DOMAttributeNames: object mapping React attribute name to the DOM\n       * attribute name. Attribute names not specified use the **lowercase**\n       * normalized name.\n       *\n       * DOMAttributeNamespaces: object mapping React attribute name to the DOM\n       * attribute namespace URL. (Attribute names not specified use no namespace.)\n       *\n       * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties.\n       * Property names not specified use the normalized name.\n       *\n       * DOMMutationMethods: Properties that require special mutation methods. If\n       * `value` is undefined, the mutation method should unset the property.\n       *\n       * @param {object} domPropertyConfig the config as described above.\n       */\n      injectDOMPropertyConfig: function (domPropertyConfig) {\n        var Injection = DOMPropertyInjection;\n        var Properties = domPropertyConfig.Properties || {};\n        var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {};\n        var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {};\n        var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {};\n\n        for (var propName in Properties) {\n          !!properties.hasOwnProperty(propName) ? invariant(false, \"injectDOMPropertyConfig(...): You're trying to inject DOM property '%s' which has already been injected. You may be accidentally injecting the same DOM property config twice, or you may be injecting two configs that have conflicting property names.\", propName) : void 0;\n\n          var lowerCased = propName.toLowerCase();\n          var propConfig = Properties[propName];\n\n          var propertyInfo = {\n            attributeName: lowerCased,\n            attributeNamespace: null,\n            propertyName: propName,\n            mutationMethod: null,\n\n            mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY),\n            hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE),\n            hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE),\n            hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE),\n            hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE),\n            hasStringBooleanValue: checkMask(propConfig, Injection.HAS_STRING_BOOLEAN_VALUE)\n          };\n          !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? invariant(false, \"DOMProperty: Value can be one of boolean, overloaded boolean, or numeric value, but not a combination: %s\", propName) : void 0;\n\n          if (DOMAttributeNames.hasOwnProperty(propName)) {\n            var attributeName = DOMAttributeNames[propName];\n\n            propertyInfo.attributeName = attributeName;\n          }\n\n          if (DOMAttributeNamespaces.hasOwnProperty(propName)) {\n            propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName];\n          }\n\n          if (DOMMutationMethods.hasOwnProperty(propName)) {\n            propertyInfo.mutationMethod = DOMMutationMethods[propName];\n          }\n\n          // Downcase references to whitelist properties to check for membership\n          // without case-sensitivity. This allows the whitelist to pick up\n          // `allowfullscreen`, which should be written using the property configuration\n          // for `allowFullscreen`\n          properties[propName] = propertyInfo;\n        }\n      }\n    };\n\n    /* eslint-disable max-len */\n    var ATTRIBUTE_NAME_START_CHAR = \":A-Z_a-z\\\\u00C0-\\\\u00D6\\\\u00D8-\\\\u00F6\\\\u00F8-\\\\u02FF\\\\u0370-\\\\u037D\\\\u037F-\\\\u1FFF\\\\u200C-\\\\u200D\\\\u2070-\\\\u218F\\\\u2C00-\\\\u2FEF\\\\u3001-\\\\uD7FF\\\\uF900-\\\\uFDCF\\\\uFDF0-\\\\uFFFD\";\n    /* eslint-enable max-len */\n    var ATTRIBUTE_NAME_CHAR = ATTRIBUTE_NAME_START_CHAR + \"\\\\-.0-9\\\\u00B7\\\\u0300-\\\\u036F\\\\u203F-\\\\u2040\";\n\n    var ROOT_ATTRIBUTE_NAME = 'data-reactroot';\n\n    /**\n     * Map from property \"standard name\" to an object with info about how to set\n     * the property in the DOM. Each object contains:\n     *\n     * attributeName:\n     *   Used when rendering markup or with `*Attribute()`.\n     * attributeNamespace\n     * propertyName:\n     *   Used on DOM node instances. (This includes properties that mutate due to\n     *   external factors.)\n     * mutationMethod:\n     *   If non-null, used instead of the property or `setAttribute()` after\n     *   initial render.\n     * mustUseProperty:\n     *   Whether the property must be accessed and mutated as an object property.\n     * hasBooleanValue:\n     *   Whether the property should be removed when set to a falsey value.\n     * hasNumericValue:\n     *   Whether the property must be numeric or parse as a numeric and should be\n     *   removed when set to a falsey value.\n     * hasPositiveNumericValue:\n     *   Whether the property must be positive numeric or parse as a positive\n     *   numeric and should be removed when set to a falsey value.\n     * hasOverloadedBooleanValue:\n     *   Whether the property can be used as a flag as well as with a value.\n     *   Removed when strictly equal to false; present without a value when\n     *   strictly equal to true; present with a value otherwise.\n     */\n    var properties = {};\n\n    /**\n     * Checks whether a property name is a writeable attribute.\n     * @method\n     */\n    function shouldSetAttribute(name, value) {\n      if (isReservedProp(name)) {\n        return false;\n      }\n      if (name.length > 2 && (name[0] === 'o' || name[0] === 'O') && (name[1] === 'n' || name[1] === 'N')) {\n        return false;\n      }\n      if (value === null) {\n        return true;\n      }\n      switch (typeof value) {\n        case 'boolean':\n          return shouldAttributeAcceptBooleanValue(name);\n        case 'undefined':\n        case 'number':\n        case 'string':\n        case 'object':\n          return true;\n        default:\n          // function, symbol\n          return false;\n      }\n    }\n\n    function getPropertyInfo(name) {\n      return properties.hasOwnProperty(name) ? properties[name] : null;\n    }\n\n    function shouldAttributeAcceptBooleanValue(name) {\n      if (isReservedProp(name)) {\n        return true;\n      }\n      var propertyInfo = getPropertyInfo(name);\n      if (propertyInfo) {\n        return propertyInfo.hasBooleanValue || propertyInfo.hasStringBooleanValue || propertyInfo.hasOverloadedBooleanValue;\n      }\n      var prefix = name.toLowerCase().slice(0, 5);\n      return prefix === 'data-' || prefix === 'aria-';\n    }\n\n    /**\n     * Checks to see if a property name is within the list of properties\n     * reserved for internal React operations. These properties should\n     * not be set on an HTML element.\n     *\n     * @private\n     * @param {string} name\n     * @return {boolean} If the name is within reserved props\n     */\n    function isReservedProp(name) {\n      return RESERVED_PROPS.hasOwnProperty(name);\n    }\n\n    var injection = DOMPropertyInjection;\n\n    var MUST_USE_PROPERTY = injection.MUST_USE_PROPERTY;\n    var HAS_BOOLEAN_VALUE = injection.HAS_BOOLEAN_VALUE;\n    var HAS_NUMERIC_VALUE = injection.HAS_NUMERIC_VALUE;\n    var HAS_POSITIVE_NUMERIC_VALUE = injection.HAS_POSITIVE_NUMERIC_VALUE;\n    var HAS_OVERLOADED_BOOLEAN_VALUE = injection.HAS_OVERLOADED_BOOLEAN_VALUE;\n    var HAS_STRING_BOOLEAN_VALUE = injection.HAS_STRING_BOOLEAN_VALUE;\n\n    var HTMLDOMPropertyConfig = {\n      // When adding attributes to this list, be sure to also add them to\n      // the `possibleStandardNames` module to ensure casing and incorrect\n      // name warnings.\n      Properties: {\n        allowFullScreen: HAS_BOOLEAN_VALUE,\n        // specifies target context for links with `preload` type\n        async: HAS_BOOLEAN_VALUE,\n        // Note: there is a special case that prevents it from being written to the DOM\n        // on the client side because the browsers are inconsistent. Instead we call focus().\n        autoFocus: HAS_BOOLEAN_VALUE,\n        autoPlay: HAS_BOOLEAN_VALUE,\n        capture: HAS_OVERLOADED_BOOLEAN_VALUE,\n        checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n        cols: HAS_POSITIVE_NUMERIC_VALUE,\n        contentEditable: HAS_STRING_BOOLEAN_VALUE,\n        controls: HAS_BOOLEAN_VALUE,\n        'default': HAS_BOOLEAN_VALUE,\n        defer: HAS_BOOLEAN_VALUE,\n        disabled: HAS_BOOLEAN_VALUE,\n        download: HAS_OVERLOADED_BOOLEAN_VALUE,\n        draggable: HAS_STRING_BOOLEAN_VALUE,\n        formNoValidate: HAS_BOOLEAN_VALUE,\n        hidden: HAS_BOOLEAN_VALUE,\n        loop: HAS_BOOLEAN_VALUE,\n        // Caution; `option.selected` is not updated if `select.multiple` is\n        // disabled with `removeAttribute`.\n        multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n        muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n        noValidate: HAS_BOOLEAN_VALUE,\n        open: HAS_BOOLEAN_VALUE,\n        playsInline: HAS_BOOLEAN_VALUE,\n        readOnly: HAS_BOOLEAN_VALUE,\n        required: HAS_BOOLEAN_VALUE,\n        reversed: HAS_BOOLEAN_VALUE,\n        rows: HAS_POSITIVE_NUMERIC_VALUE,\n        rowSpan: HAS_NUMERIC_VALUE,\n        scoped: HAS_BOOLEAN_VALUE,\n        seamless: HAS_BOOLEAN_VALUE,\n        selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE,\n        size: HAS_POSITIVE_NUMERIC_VALUE,\n        start: HAS_NUMERIC_VALUE,\n        // support for projecting regular DOM Elements via V1 named slots ( shadow dom )\n        span: HAS_POSITIVE_NUMERIC_VALUE,\n        spellCheck: HAS_STRING_BOOLEAN_VALUE,\n        // Style must be explicitly set in the attribute list. React components\n        // expect a style object\n        style: 0,\n        // Keep it in the whitelist because it is case-sensitive for SVG.\n        tabIndex: 0,\n        // itemScope is for for Microdata support.\n        // See http://schema.org/docs/gs.html\n        itemScope: HAS_BOOLEAN_VALUE,\n        // These attributes must stay in the white-list because they have\n        // different attribute names (see DOMAttributeNames below)\n        acceptCharset: 0,\n        className: 0,\n        htmlFor: 0,\n        httpEquiv: 0,\n        // Attributes with mutation methods must be specified in the whitelist\n        // Set the string boolean flag to allow the behavior\n        value: HAS_STRING_BOOLEAN_VALUE\n      },\n      DOMAttributeNames: {\n        acceptCharset: 'accept-charset',\n        className: 'class',\n        htmlFor: 'for',\n        httpEquiv: 'http-equiv'\n      },\n      DOMMutationMethods: {\n        value: function (node, value) {\n          if (value == null) {\n            return node.removeAttribute('value');\n          }\n\n          // Number inputs get special treatment due to some edge cases in\n          // Chrome. Let everything else assign the value attribute as normal.\n          // https://github.com/facebook/react/issues/7253#issuecomment-236074326\n          if (node.type !== 'number' || node.hasAttribute('value') === false) {\n            node.setAttribute('value', '' + value);\n          } else if (node.validity && !node.validity.badInput && node.ownerDocument.activeElement !== node) {\n            // Don't assign an attribute if validation reports bad\n            // input. Chrome will clear the value. Additionally, don't\n            // operate on inputs that have focus, otherwise Chrome might\n            // strip off trailing decimal places and cause the user's\n            // cursor position to jump to the beginning of the input.\n            //\n            // In ReactDOMInput, we have an onBlur event that will trigger\n            // this function again when focus is lost.\n            node.setAttribute('value', '' + value);\n          }\n        }\n      }\n    };\n\n    var HAS_STRING_BOOLEAN_VALUE$1 = injection.HAS_STRING_BOOLEAN_VALUE;\n\n    var NS = {\n      xlink: 'http://www.w3.org/1999/xlink',\n      xml: 'http://www.w3.org/XML/1998/namespace'\n    };\n\n    /**\n     * This is a list of all SVG attributes that need special casing,\n     * namespacing, or boolean value assignment.\n     *\n     * When adding attributes to this list, be sure to also add them to\n     * the `possibleStandardNames` module to ensure casing and incorrect\n     * name warnings.\n     *\n     * SVG Attributes List:\n     * https://www.w3.org/TR/SVG/attindex.html\n     * SMIL Spec:\n     * https://www.w3.org/TR/smil\n     */\n    var ATTRS = ['accent-height', 'alignment-baseline', 'arabic-form', 'baseline-shift', 'cap-height', 'clip-path', 'clip-rule', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'dominant-baseline', 'enable-background', 'fill-opacity', 'fill-rule', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'glyph-name', 'glyph-orientation-horizontal', 'glyph-orientation-vertical', 'horiz-adv-x', 'horiz-origin-x', 'image-rendering', 'letter-spacing', 'lighting-color', 'marker-end', 'marker-mid', 'marker-start', 'overline-position', 'overline-thickness', 'paint-order', 'panose-1', 'pointer-events', 'rendering-intent', 'shape-rendering', 'stop-color', 'stop-opacity', 'strikethrough-position', 'strikethrough-thickness', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke-width', 'text-anchor', 'text-decoration', 'text-rendering', 'underline-position', 'underline-thickness', 'unicode-bidi', 'unicode-range', 'units-per-em', 'v-alphabetic', 'v-hanging', 'v-ideographic', 'v-mathematical', 'vector-effect', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'word-spacing', 'writing-mode', 'x-height', 'xlink:actuate', 'xlink:arcrole', 'xlink:href', 'xlink:role', 'xlink:show', 'xlink:title', 'xlink:type', 'xml:base', 'xmlns:xlink', 'xml:lang', 'xml:space'];\n\n    var SVGDOMPropertyConfig = {\n      Properties: {\n        autoReverse: HAS_STRING_BOOLEAN_VALUE$1,\n        externalResourcesRequired: HAS_STRING_BOOLEAN_VALUE$1,\n        preserveAlpha: HAS_STRING_BOOLEAN_VALUE$1\n      },\n      DOMAttributeNames: {\n        autoReverse: 'autoReverse',\n        externalResourcesRequired: 'externalResourcesRequired',\n        preserveAlpha: 'preserveAlpha'\n      },\n      DOMAttributeNamespaces: {\n        xlinkActuate: NS.xlink,\n        xlinkArcrole: NS.xlink,\n        xlinkHref: NS.xlink,\n        xlinkRole: NS.xlink,\n        xlinkShow: NS.xlink,\n        xlinkTitle: NS.xlink,\n        xlinkType: NS.xlink,\n        xmlBase: NS.xml,\n        xmlLang: NS.xml,\n        xmlSpace: NS.xml\n      }\n    };\n\n    var CAMELIZE = /[\\-\\:]([a-z])/g;\n    var capitalize = function (token) {\n      return token[1].toUpperCase();\n    };\n\n    ATTRS.forEach(function (original) {\n      var reactName = original.replace(CAMELIZE, capitalize);\n\n      SVGDOMPropertyConfig.Properties[reactName] = 0;\n      SVGDOMPropertyConfig.DOMAttributeNames[reactName] = original;\n    });\n\n    injection.injectDOMPropertyConfig(HTMLDOMPropertyConfig);\n    injection.injectDOMPropertyConfig(SVGDOMPropertyConfig);\n\n    var ReactErrorUtils = {\n      // Used by Fiber to simulate a try-catch.\n      _caughtError: null,\n      _hasCaughtError: false,\n\n      // Used by event system to capture/rethrow the first error.\n      _rethrowError: null,\n      _hasRethrowError: false,\n\n      injection: {\n        injectErrorUtils: function (injectedErrorUtils) {\n          !(typeof injectedErrorUtils.invokeGuardedCallback === 'function') ? invariant(false, 'Injected invokeGuardedCallback() must be a function.') : void 0;\n          invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;\n        }\n      },\n\n      /**\n       * Call a function while guarding against errors that happens within it.\n       * Returns an error if it throws, otherwise null.\n       *\n       * In production, this is implemented using a try-catch. The reason we don't\n       * use a try-catch directly is so that we can swap out a different\n       * implementation in DEV mode.\n       *\n       * @param {String} name of the guard to use for logging or debugging\n       * @param {Function} func The function to invoke\n       * @param {*} context The context to use when calling the function\n       * @param {...*} args Arguments for function\n       */\n      invokeGuardedCallback: function (name, func, context, a, b, c, d, e, f) {\n        invokeGuardedCallback.apply(ReactErrorUtils, arguments);\n      },\n\n      /**\n       * Same as invokeGuardedCallback, but instead of returning an error, it stores\n       * it in a global so it can be rethrown by `rethrowCaughtError` later.\n       * TODO: See if _caughtError and _rethrowError can be unified.\n       *\n       * @param {String} name of the guard to use for logging or debugging\n       * @param {Function} func The function to invoke\n       * @param {*} context The context to use when calling the function\n       * @param {...*} args Arguments for function\n       */\n      invokeGuardedCallbackAndCatchFirstError: function (name, func, context, a, b, c, d, e, f) {\n        ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);\n        if (ReactErrorUtils.hasCaughtError()) {\n          var error = ReactErrorUtils.clearCaughtError();\n          if (!ReactErrorUtils._hasRethrowError) {\n            ReactErrorUtils._hasRethrowError = true;\n            ReactErrorUtils._rethrowError = error;\n          }\n        }\n      },\n\n      /**\n       * During execution of guarded functions we will capture the first error which\n       * we will rethrow to be handled by the top level error handler.\n       */\n      rethrowCaughtError: function () {\n        return rethrowCaughtError.apply(ReactErrorUtils, arguments);\n      },\n\n      hasCaughtError: function () {\n        return ReactErrorUtils._hasCaughtError;\n      },\n\n      clearCaughtError: function () {\n        if (ReactErrorUtils._hasCaughtError) {\n          var error = ReactErrorUtils._caughtError;\n          ReactErrorUtils._caughtError = null;\n          ReactErrorUtils._hasCaughtError = false;\n          return error;\n        } else {\n          invariant(false, 'clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.');\n        }\n      }\n    };\n\n    var invokeGuardedCallback = function (name, func, context, a, b, c, d, e, f) {\n      ReactErrorUtils._hasCaughtError = false;\n      ReactErrorUtils._caughtError = null;\n      var funcArgs = Array.prototype.slice.call(arguments, 3);\n      try {\n        func.apply(context, funcArgs);\n      } catch (error) {\n        ReactErrorUtils._caughtError = error;\n        ReactErrorUtils._hasCaughtError = true;\n      }\n    };\n\n    {\n      // In DEV mode, we swap out invokeGuardedCallback for a special version\n      // that plays more nicely with the browser's DevTools. The idea is to preserve\n      // \"Pause on exceptions\" behavior. Because React wraps all user-provided\n      // functions in invokeGuardedCallback, and the production version of\n      // invokeGuardedCallback uses a try-catch, all user exceptions are treated\n      // like caught exceptions, and the DevTools won't pause unless the developer\n      // takes the extra step of enabling pause on caught exceptions. This is\n      // untintuitive, though, because even though React has caught the error, from\n      // the developer's perspective, the error is uncaught.\n      //\n      // To preserve the expected \"Pause on exceptions\" behavior, we don't use a\n      // try-catch in DEV. Instead, we synchronously dispatch a fake event to a fake\n      // DOM node, and call the user-provided callback from inside an event handler\n      // for that fake event. If the callback throws, the error is \"captured\" using\n      // a global event handler. But because the error happens in a different\n      // event loop context, it does not interrupt the normal program flow.\n      // Effectively, this gives us try-catch behavior without actually using\n      // try-catch. Neat!\n\n      // Check that the browser supports the APIs we need to implement our special\n      // DEV version of invokeGuardedCallback\n      if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') {\n        var fakeNode = document.createElement('react');\n\n        var invokeGuardedCallbackDev = function (name, func, context, a, b, c, d, e, f) {\n          // Keeps track of whether the user-provided callback threw an error. We\n          // set this to true at the beginning, then set it to false right after\n          // calling the function. If the function errors, `didError` will never be\n          // set to false. This strategy works even if the browser is flaky and\n          // fails to call our global error handler, because it doesn't rely on\n          // the error event at all.\n          var didError = true;\n\n          // Create an event handler for our fake event. We will synchronously\n          // dispatch our fake event using `dispatchEvent`. Inside the handler, we\n          // call the user-provided callback.\n          var funcArgs = Array.prototype.slice.call(arguments, 3);\n          function callCallback() {\n            // We immediately remove the callback from event listeners so that\n            // nested `invokeGuardedCallback` calls do not clash. Otherwise, a\n            // nested call would trigger the fake event handlers of any call higher\n            // in the stack.\n            fakeNode.removeEventListener(evtType, callCallback, false);\n            func.apply(context, funcArgs);\n            didError = false;\n          }\n\n          // Create a global error event handler. We use this to capture the value\n          // that was thrown. It's possible that this error handler will fire more\n          // than once; for example, if non-React code also calls `dispatchEvent`\n          // and a handler for that event throws. We should be resilient to most of\n          // those cases. Even if our error event handler fires more than once, the\n          // last error event is always used. If the callback actually does error,\n          // we know that the last error event is the correct one, because it's not\n          // possible for anything else to have happened in between our callback\n          // erroring and the code that follows the `dispatchEvent` call below. If\n          // the callback doesn't error, but the error event was fired, we know to\n          // ignore it because `didError` will be false, as described above.\n          var error = void 0;\n          // Use this to track whether the error event is ever called.\n          var didSetError = false;\n          var isCrossOriginError = false;\n\n          function onError(event) {\n            error = event.error;\n            didSetError = true;\n            if (error === null && event.colno === 0 && event.lineno === 0) {\n              isCrossOriginError = true;\n            }\n          }\n\n          // Create a fake event type.\n          var evtType = 'react-' + (name ? name : 'invokeguardedcallback');\n\n          // Attach our event handlers\n          window.addEventListener('error', onError);\n          fakeNode.addEventListener(evtType, callCallback, false);\n\n          // Synchronously dispatch our fake event. If the user-provided function\n          // errors, it will trigger our global error handler.\n          var evt = document.createEvent('Event');\n          evt.initEvent(evtType, false, false);\n          fakeNode.dispatchEvent(evt);\n\n          if (didError) {\n            if (!didSetError) {\n              // The callback errored, but the error event never fired.\n              error = new Error('An error was thrown inside one of your components, but React ' + \"doesn't know what it was. This is likely due to browser \" + 'flakiness. React does its best to preserve the \"Pause on ' + 'exceptions\" behavior of the DevTools, which requires some ' + \"DEV-mode only tricks. It's possible that these don't work in \" + 'your browser. Try triggering the error in production mode, ' + 'or switching to a modern browser. If you suspect that this is ' + 'actually an issue with React, please file an issue.');\n            } else if (isCrossOriginError) {\n              error = new Error(\"A cross-origin error was thrown. React doesn't have access to \" + 'the actual error object in development. ' + 'See https://fb.me/react-crossorigin-error for more information.');\n            }\n            ReactErrorUtils._hasCaughtError = true;\n            ReactErrorUtils._caughtError = error;\n          } else {\n            ReactErrorUtils._hasCaughtError = false;\n            ReactErrorUtils._caughtError = null;\n          }\n\n          // Remove our event listeners\n          window.removeEventListener('error', onError);\n        };\n\n        invokeGuardedCallback = invokeGuardedCallbackDev;\n      }\n    }\n\n    var rethrowCaughtError = function () {\n      if (ReactErrorUtils._hasRethrowError) {\n        var error = ReactErrorUtils._rethrowError;\n        ReactErrorUtils._rethrowError = null;\n        ReactErrorUtils._hasRethrowError = false;\n        throw error;\n      }\n    };\n\n    /**\n     * Injectable ordering of event plugins.\n     */\n    var eventPluginOrder = null;\n\n    /**\n     * Injectable mapping from names to event plugin modules.\n     */\n    var namesToPlugins = {};\n\n    /**\n     * Recomputes the plugin list using the injected plugins and plugin ordering.\n     *\n     * @private\n     */\n    function recomputePluginOrdering() {\n      if (!eventPluginOrder) {\n        // Wait until an `eventPluginOrder` is injected.\n        return;\n      }\n      for (var pluginName in namesToPlugins) {\n        var pluginModule = namesToPlugins[pluginName];\n        var pluginIndex = eventPluginOrder.indexOf(pluginName);\n        !(pluginIndex > -1) ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : void 0;\n        if (plugins[pluginIndex]) {\n          continue;\n        }\n        !pluginModule.extractEvents ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : void 0;\n        plugins[pluginIndex] = pluginModule;\n        var publishedEvents = pluginModule.eventTypes;\n        for (var eventName in publishedEvents) {\n          !publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : void 0;\n        }\n      }\n    }\n\n    /**\n     * Publishes an event so that it can be dispatched by the supplied plugin.\n     *\n     * @param {object} dispatchConfig Dispatch configuration for the event.\n     * @param {object} PluginModule Plugin publishing the event.\n     * @return {boolean} True if the event was successfully published.\n     * @private\n     */\n    function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {\n      !!eventNameDispatchConfigs.hasOwnProperty(eventName) ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : void 0;\n      eventNameDispatchConfigs[eventName] = dispatchConfig;\n\n      var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;\n      if (phasedRegistrationNames) {\n        for (var phaseName in phasedRegistrationNames) {\n          if (phasedRegistrationNames.hasOwnProperty(phaseName)) {\n            var phasedRegistrationName = phasedRegistrationNames[phaseName];\n            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);\n          }\n        }\n        return true;\n      } else if (dispatchConfig.registrationName) {\n        publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);\n        return true;\n      }\n      return false;\n    }\n\n    /**\n     * Publishes a registration name that is used to identify dispatched events.\n     *\n     * @param {string} registrationName Registration name to add.\n     * @param {object} PluginModule Plugin publishing the event.\n     * @private\n     */\n    function publishRegistrationName(registrationName, pluginModule, eventName) {\n      !!registrationNameModules[registrationName] ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : void 0;\n      registrationNameModules[registrationName] = pluginModule;\n      registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;\n\n      {\n        var lowerCasedName = registrationName.toLowerCase();\n        possibleRegistrationNames[lowerCasedName] = registrationName;\n\n        if (registrationName === 'onDoubleClick') {\n          possibleRegistrationNames.ondblclick = registrationName;\n        }\n      }\n    }\n\n    /**\n     * Registers plugins so that they can extract and dispatch events.\n     *\n     * @see {EventPluginHub}\n     */\n\n    /**\n     * Ordered list of injected plugins.\n     */\n    var plugins = [];\n\n    /**\n     * Mapping from event name to dispatch config\n     */\n    var eventNameDispatchConfigs = {};\n\n    /**\n     * Mapping from registration name to plugin module\n     */\n    var registrationNameModules = {};\n\n    /**\n     * Mapping from registration name to event name\n     */\n    var registrationNameDependencies = {};\n\n    /**\n     * Mapping from lowercase registration names to the properly cased version,\n     * used to warn in the case of missing event handlers. Available\n     * only in true.\n     * @type {Object}\n     */\n    var possibleRegistrationNames = {};\n    // Trust the developer to only use possibleRegistrationNames in true\n\n    /**\n     * Injects an ordering of plugins (by plugin name). This allows the ordering\n     * to be decoupled from injection of the actual plugins so that ordering is\n     * always deterministic regardless of packaging, on-the-fly injection, etc.\n     *\n     * @param {array} InjectedEventPluginOrder\n     * @internal\n     * @see {EventPluginHub.injection.injectEventPluginOrder}\n     */\n    function injectEventPluginOrder(injectedEventPluginOrder) {\n      !!eventPluginOrder ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React.') : void 0;\n      // Clone the ordering so it cannot be dynamically mutated.\n      eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);\n      recomputePluginOrdering();\n    }\n\n    /**\n     * Injects plugins to be used by `EventPluginHub`. The plugin names must be\n     * in the ordering injected by `injectEventPluginOrder`.\n     *\n     * Plugins can be injected as part of page initialization or on-the-fly.\n     *\n     * @param {object} injectedNamesToPlugins Map from names to plugin modules.\n     * @internal\n     * @see {EventPluginHub.injection.injectEventPluginsByName}\n     */\n    function injectEventPluginsByName(injectedNamesToPlugins) {\n      var isOrderingDirty = false;\n      for (var pluginName in injectedNamesToPlugins) {\n        if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {\n          continue;\n        }\n        var pluginModule = injectedNamesToPlugins[pluginName];\n        if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {\n          !!namesToPlugins[pluginName] ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.', pluginName) : void 0;\n          namesToPlugins[pluginName] = pluginModule;\n          isOrderingDirty = true;\n        }\n      }\n      if (isOrderingDirty) {\n        recomputePluginOrdering();\n      }\n    }\n\n    var EventPluginRegistry = Object.freeze({\n      plugins: plugins,\n      eventNameDispatchConfigs: eventNameDispatchConfigs,\n      registrationNameModules: registrationNameModules,\n      registrationNameDependencies: registrationNameDependencies,\n      possibleRegistrationNames: possibleRegistrationNames,\n      injectEventPluginOrder: injectEventPluginOrder,\n      injectEventPluginsByName: injectEventPluginsByName\n    });\n\n    var getFiberCurrentPropsFromNode = null;\n    var getInstanceFromNode = null;\n    var getNodeFromInstance = null;\n\n    var injection$2 = {\n      injectComponentTree: function (Injected) {\n        getFiberCurrentPropsFromNode = Injected.getFiberCurrentPropsFromNode;\n        getInstanceFromNode = Injected.getInstanceFromNode;\n        getNodeFromInstance = Injected.getNodeFromInstance;\n\n        {\n          warning(getNodeFromInstance && getInstanceFromNode, 'EventPluginUtils.injection.injectComponentTree(...): Injected ' + 'module is missing getNodeFromInstance or getInstanceFromNode.');\n        }\n      }\n    };\n\n    var validateEventDispatches;\n    {\n      validateEventDispatches = function (event) {\n        var dispatchListeners = event._dispatchListeners;\n        var dispatchInstances = event._dispatchInstances;\n\n        var listenersIsArr = Array.isArray(dispatchListeners);\n        var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;\n\n        var instancesIsArr = Array.isArray(dispatchInstances);\n        var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;\n\n        warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, 'EventPluginUtils: Invalid `event`.');\n      };\n    }\n\n    /**\n     * Dispatch the event to the listener.\n     * @param {SyntheticEvent} event SyntheticEvent to handle\n     * @param {boolean} simulated If the event is simulated (changes exn behavior)\n     * @param {function} listener Application-level callback\n     * @param {*} inst Internal component instance\n     */\n    function executeDispatch(event, simulated, listener, inst) {\n      var type = event.type || 'unknown-event';\n      event.currentTarget = getNodeFromInstance(inst);\n      ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);\n      event.currentTarget = null;\n    }\n\n    /**\n     * Standard/simple iteration through an event's collected dispatches.\n     */\n    function executeDispatchesInOrder(event, simulated) {\n      var dispatchListeners = event._dispatchListeners;\n      var dispatchInstances = event._dispatchInstances;\n      {\n        validateEventDispatches(event);\n      }\n      if (Array.isArray(dispatchListeners)) {\n        for (var i = 0; i < dispatchListeners.length; i++) {\n          if (event.isPropagationStopped()) {\n            break;\n          }\n          // Listeners and Instances are two parallel arrays that are always in sync.\n          executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);\n        }\n      } else if (dispatchListeners) {\n        executeDispatch(event, simulated, dispatchListeners, dispatchInstances);\n      }\n      event._dispatchListeners = null;\n      event._dispatchInstances = null;\n    }\n\n    /**\n     * @see executeDispatchesInOrderStopAtTrueImpl\n     */\n\n    /**\n     * Execution of a \"direct\" dispatch - there must be at most one dispatch\n     * accumulated on the event or it is considered an error. It doesn't really make\n     * sense for an event with multiple dispatches (bubbled) to keep track of the\n     * return values at each dispatch execution, but it does tend to make sense when\n     * dealing with \"direct\" dispatches.\n     *\n     * @return {*} The return value of executing the single dispatch.\n     */\n\n    /**\n     * @param {SyntheticEvent} event\n     * @return {boolean} True iff number of dispatches accumulated is greater than 0.\n     */\n\n    /**\n     * Accumulates items that must not be null or undefined into the first one. This\n     * is used to conserve memory by avoiding array allocations, and thus sacrifices\n     * API cleanness. Since `current` can be null before being passed in and not\n     * null after this function, make sure to assign it back to `current`:\n     *\n     * `a = accumulateInto(a, b);`\n     *\n     * This API should be sparingly used. Try `accumulate` for something cleaner.\n     *\n     * @return {*|array<*>} An accumulation of items.\n     */\n\n    function accumulateInto(current, next) {\n      !(next != null) ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : void 0;\n\n      if (current == null) {\n        return next;\n      }\n\n      // Both are not empty. Warning: Never call x.concat(y) when you are not\n      // certain that x is an Array (x could be a string with concat method).\n      if (Array.isArray(current)) {\n        if (Array.isArray(next)) {\n          current.push.apply(current, next);\n          return current;\n        }\n        current.push(next);\n        return current;\n      }\n\n      if (Array.isArray(next)) {\n        // A bit too dangerous to mutate `next`.\n        return [current].concat(next);\n      }\n\n      return [current, next];\n    }\n\n    /**\n     * @param {array} arr an \"accumulation\" of items which is either an Array or\n     * a single item. Useful when paired with the `accumulate` module. This is a\n     * simple utility that allows us to reason about a collection of items, but\n     * handling the case when there is exactly one item (and we do not need to\n     * allocate an array).\n     * @param {function} cb Callback invoked with each element or a collection.\n     * @param {?} [scope] Scope used as `this` in a callback.\n     */\n    function forEachAccumulated(arr, cb, scope) {\n      if (Array.isArray(arr)) {\n        arr.forEach(cb, scope);\n      } else if (arr) {\n        cb.call(scope, arr);\n      }\n    }\n\n    /**\n     * Internal queue of events that have accumulated their dispatches and are\n     * waiting to have their dispatches executed.\n     */\n    var eventQueue = null;\n\n    /**\n     * Dispatches an event and releases it back into the pool, unless persistent.\n     *\n     * @param {?object} event Synthetic event to be dispatched.\n     * @param {boolean} simulated If the event is simulated (changes exn behavior)\n     * @private\n     */\n    var executeDispatchesAndRelease = function (event, simulated) {\n      if (event) {\n        executeDispatchesInOrder(event, simulated);\n\n        if (!event.isPersistent()) {\n          event.constructor.release(event);\n        }\n      }\n    };\n    var executeDispatchesAndReleaseSimulated = function (e) {\n      return executeDispatchesAndRelease(e, true);\n    };\n    var executeDispatchesAndReleaseTopLevel = function (e) {\n      return executeDispatchesAndRelease(e, false);\n    };\n\n    function isInteractive(tag) {\n      return tag === 'button' || tag === 'input' || tag === 'select' || tag === 'textarea';\n    }\n\n    function shouldPreventMouseEvent(name, type, props) {\n      switch (name) {\n        case 'onClick':\n        case 'onClickCapture':\n        case 'onDoubleClick':\n        case 'onDoubleClickCapture':\n        case 'onMouseDown':\n        case 'onMouseDownCapture':\n        case 'onMouseMove':\n        case 'onMouseMoveCapture':\n        case 'onMouseUp':\n        case 'onMouseUpCapture':\n          return !!(props.disabled && isInteractive(type));\n        default:\n          return false;\n      }\n    }\n\n    /**\n     * This is a unified interface for event plugins to be installed and configured.\n     *\n     * Event plugins can implement the following properties:\n     *\n     *   `extractEvents` {function(string, DOMEventTarget, string, object): *}\n     *     Required. When a top-level event is fired, this method is expected to\n     *     extract synthetic events that will in turn be queued and dispatched.\n     *\n     *   `eventTypes` {object}\n     *     Optional, plugins that fire events must publish a mapping of registration\n     *     names that are used to register listeners. Values of this mapping must\n     *     be objects that contain `registrationName` or `phasedRegistrationNames`.\n     *\n     *   `executeDispatch` {function(object, function, string)}\n     *     Optional, allows plugins to override how an event gets dispatched. By\n     *     default, the listener is simply invoked.\n     *\n     * Each plugin that is injected into `EventsPluginHub` is immediately operable.\n     *\n     * @public\n     */\n\n    /**\n     * Methods for injecting dependencies.\n     */\n    var injection$1 = {\n      /**\n       * @param {array} InjectedEventPluginOrder\n       * @public\n       */\n      injectEventPluginOrder: injectEventPluginOrder,\n\n      /**\n       * @param {object} injectedNamesToPlugins Map from names to plugin modules.\n       */\n      injectEventPluginsByName: injectEventPluginsByName\n    };\n\n    /**\n     * @param {object} inst The instance, which is the source of events.\n     * @param {string} registrationName Name of listener (e.g. `onClick`).\n     * @return {?function} The stored callback.\n     */\n    function getListener(inst, registrationName) {\n      var listener;\n\n      // TODO: shouldPreventMouseEvent is DOM-specific and definitely should not\n      // live here; needs to be moved to a better place soon\n      var stateNode = inst.stateNode;\n      if (!stateNode) {\n        // Work in progress (ex: onload events in incremental mode).\n        return null;\n      }\n      var props = getFiberCurrentPropsFromNode(stateNode);\n      if (!props) {\n        // Work in progress.\n        return null;\n      }\n      listener = props[registrationName];\n      if (shouldPreventMouseEvent(registrationName, inst.type, props)) {\n        return null;\n      }\n      !(!listener || typeof listener === 'function') ? invariant(false, 'Expected `%s` listener to be a function, instead got a value of `%s` type.', registrationName, typeof listener) : void 0;\n      return listener;\n    }\n\n    /**\n     * Allows registered plugins an opportunity to extract events from top-level\n     * native browser events.\n     *\n     * @return {*} An accumulation of synthetic events.\n     * @internal\n     */\n    function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n      var events;\n      for (var i = 0; i < plugins.length; i++) {\n        // Not every plugin in the ordering may be loaded at runtime.\n        var possiblePlugin = plugins[i];\n        if (possiblePlugin) {\n          var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);\n          if (extractedEvents) {\n            events = accumulateInto(events, extractedEvents);\n          }\n        }\n      }\n      return events;\n    }\n\n    /**\n     * Enqueues a synthetic event that should be dispatched when\n     * `processEventQueue` is invoked.\n     *\n     * @param {*} events An accumulation of synthetic events.\n     * @internal\n     */\n    function enqueueEvents(events) {\n      if (events) {\n        eventQueue = accumulateInto(eventQueue, events);\n      }\n    }\n\n    /**\n     * Dispatches all synthetic events on the event queue.\n     *\n     * @internal\n     */\n    function processEventQueue(simulated) {\n      // Set `eventQueue` to null before processing it so that we can tell if more\n      // events get enqueued while processing.\n      var processingEventQueue = eventQueue;\n      eventQueue = null;\n\n      if (!processingEventQueue) {\n        return;\n      }\n\n      if (simulated) {\n        forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);\n      } else {\n        forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);\n      }\n      !!eventQueue ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented.') : void 0;\n      // This would be a good time to rethrow if any of the event handlers threw.\n      ReactErrorUtils.rethrowCaughtError();\n    }\n\n    var EventPluginHub = Object.freeze({\n      injection: injection$1,\n      getListener: getListener,\n      extractEvents: extractEvents,\n      enqueueEvents: enqueueEvents,\n      processEventQueue: processEventQueue\n    });\n\n    var IndeterminateComponent = 0; // Before we know whether it is functional or class\n    var FunctionalComponent = 1;\n    var ClassComponent = 2;\n    var HostRoot = 3; // Root of a host tree. Could be nested inside another node.\n    var HostPortal = 4; // A subtree. Could be an entry point to a different renderer.\n    var HostComponent = 5;\n    var HostText = 6;\n    var CallComponent = 7;\n    var CallHandlerPhase = 8;\n    var ReturnComponent = 9;\n    var Fragment = 10;\n\n    var randomKey = Math.random().toString(36).slice(2);\n    var internalInstanceKey = '__reactInternalInstance$' + randomKey;\n    var internalEventHandlersKey = '__reactEventHandlers$' + randomKey;\n\n    function precacheFiberNode$1(hostInst, node) {\n      node[internalInstanceKey] = hostInst;\n    }\n\n    /**\n     * Given a DOM node, return the closest ReactDOMComponent or\n     * ReactDOMTextComponent instance ancestor.\n     */\n    function getClosestInstanceFromNode(node) {\n      if (node[internalInstanceKey]) {\n        return node[internalInstanceKey];\n      }\n\n      // Walk up the tree until we find an ancestor whose instance we have cached.\n      var parents = [];\n      while (!node[internalInstanceKey]) {\n        parents.push(node);\n        if (node.parentNode) {\n          node = node.parentNode;\n        } else {\n          // Top of the tree. This node must not be part of a React tree (or is\n          // unmounted, potentially).\n          return null;\n        }\n      }\n\n      var closest = void 0;\n      var inst = node[internalInstanceKey];\n      if (inst.tag === HostComponent || inst.tag === HostText) {\n        // In Fiber, this will always be the deepest root.\n        return inst;\n      }\n      for (; node && (inst = node[internalInstanceKey]); node = parents.pop()) {\n        closest = inst;\n      }\n\n      return closest;\n    }\n\n    /**\n     * Given a DOM node, return the ReactDOMComponent or ReactDOMTextComponent\n     * instance, or null if the node was not rendered by this React.\n     */\n    function getInstanceFromNode$1(node) {\n      var inst = node[internalInstanceKey];\n      if (inst) {\n        if (inst.tag === HostComponent || inst.tag === HostText) {\n          return inst;\n        } else {\n          return null;\n        }\n      }\n      return null;\n    }\n\n    /**\n     * Given a ReactDOMComponent or ReactDOMTextComponent, return the corresponding\n     * DOM node.\n     */\n    function getNodeFromInstance$1(inst) {\n      if (inst.tag === HostComponent || inst.tag === HostText) {\n        // In Fiber this, is just the state node right now. We assume it will be\n        // a host component or host text.\n        return inst.stateNode;\n      }\n\n      // Without this first invariant, passing a non-DOM-component triggers the next\n      // invariant for a missing parent, which is super confusing.\n      invariant(false, 'getNodeFromInstance: Invalid argument.');\n    }\n\n    function getFiberCurrentPropsFromNode$1(node) {\n      return node[internalEventHandlersKey] || null;\n    }\n\n    function updateFiberProps$1(node, props) {\n      node[internalEventHandlersKey] = props;\n    }\n\n    var ReactDOMComponentTree = Object.freeze({\n      precacheFiberNode: precacheFiberNode$1,\n      getClosestInstanceFromNode: getClosestInstanceFromNode,\n      getInstanceFromNode: getInstanceFromNode$1,\n      getNodeFromInstance: getNodeFromInstance$1,\n      getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode$1,\n      updateFiberProps: updateFiberProps$1\n    });\n\n    function getParent(inst) {\n      do {\n        inst = inst['return'];\n        // TODO: If this is a HostRoot we might want to bail out.\n        // That is depending on if we want nested subtrees (layers) to bubble\n        // events to their parent. We could also go through parentNode on the\n        // host node but that wouldn't work for React Native and doesn't let us\n        // do the portal feature.\n      } while (inst && inst.tag !== HostComponent);\n      if (inst) {\n        return inst;\n      }\n      return null;\n    }\n\n    /**\n     * Return the lowest common ancestor of A and B, or null if they are in\n     * different trees.\n     */\n    function getLowestCommonAncestor(instA, instB) {\n      var depthA = 0;\n      for (var tempA = instA; tempA; tempA = getParent(tempA)) {\n        depthA++;\n      }\n      var depthB = 0;\n      for (var tempB = instB; tempB; tempB = getParent(tempB)) {\n        depthB++;\n      }\n\n      // If A is deeper, crawl up.\n      while (depthA - depthB > 0) {\n        instA = getParent(instA);\n        depthA--;\n      }\n\n      // If B is deeper, crawl up.\n      while (depthB - depthA > 0) {\n        instB = getParent(instB);\n        depthB--;\n      }\n\n      // Walk in lockstep until we find a match.\n      var depth = depthA;\n      while (depth--) {\n        if (instA === instB || instA === instB.alternate) {\n          return instA;\n        }\n        instA = getParent(instA);\n        instB = getParent(instB);\n      }\n      return null;\n    }\n\n    /**\n     * Return if A is an ancestor of B.\n     */\n\n    /**\n     * Return the parent instance of the passed-in instance.\n     */\n    function getParentInstance(inst) {\n      return getParent(inst);\n    }\n\n    /**\n     * Simulates the traversal of a two-phase, capture/bubble event dispatch.\n     */\n    function traverseTwoPhase(inst, fn, arg) {\n      var path = [];\n      while (inst) {\n        path.push(inst);\n        inst = getParent(inst);\n      }\n      var i;\n      for (i = path.length; i-- > 0;) {\n        fn(path[i], 'captured', arg);\n      }\n      for (i = 0; i < path.length; i++) {\n        fn(path[i], 'bubbled', arg);\n      }\n    }\n\n    /**\n     * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that\n     * should would receive a `mouseEnter` or `mouseLeave` event.\n     *\n     * Does not invoke the callback on the nearest common ancestor because nothing\n     * \"entered\" or \"left\" that element.\n     */\n    function traverseEnterLeave(from, to, fn, argFrom, argTo) {\n      var common = from && to ? getLowestCommonAncestor(from, to) : null;\n      var pathFrom = [];\n      while (true) {\n        if (!from) {\n          break;\n        }\n        if (from === common) {\n          break;\n        }\n        var alternate = from.alternate;\n        if (alternate !== null && alternate === common) {\n          break;\n        }\n        pathFrom.push(from);\n        from = getParent(from);\n      }\n      var pathTo = [];\n      while (true) {\n        if (!to) {\n          break;\n        }\n        if (to === common) {\n          break;\n        }\n        var _alternate = to.alternate;\n        if (_alternate !== null && _alternate === common) {\n          break;\n        }\n        pathTo.push(to);\n        to = getParent(to);\n      }\n      for (var i = 0; i < pathFrom.length; i++) {\n        fn(pathFrom[i], 'bubbled', argFrom);\n      }\n      for (var _i = pathTo.length; _i-- > 0;) {\n        fn(pathTo[_i], 'captured', argTo);\n      }\n    }\n\n    /**\n     * Some event types have a notion of different registration names for different\n     * \"phases\" of propagation. This finds listeners by a given phase.\n     */\n    function listenerAtPhase(inst, event, propagationPhase) {\n      var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];\n      return getListener(inst, registrationName);\n    }\n\n    /**\n     * A small set of propagation patterns, each of which will accept a small amount\n     * of information, and generate a set of \"dispatch ready event objects\" - which\n     * are sets of events that have already been annotated with a set of dispatched\n     * listener functions/ids. The API is designed this way to discourage these\n     * propagation strategies from actually executing the dispatches, since we\n     * always want to collect the entire set of dispatches before executing even a\n     * single one.\n     */\n\n    /**\n     * Tags a `SyntheticEvent` with dispatched listeners. Creating this function\n     * here, allows us to not have to bind or create functions for each event.\n     * Mutating the event's members allows us to not have to create a wrapping\n     * \"dispatch\" object that pairs the event with the listener.\n     */\n    function accumulateDirectionalDispatches(inst, phase, event) {\n      {\n        warning(inst, 'Dispatching inst must not be null');\n      }\n      var listener = listenerAtPhase(inst, event, phase);\n      if (listener) {\n        event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);\n        event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);\n      }\n    }\n\n    /**\n     * Collect dispatches (must be entirely collected before dispatching - see unit\n     * tests). Lazily allocate the array to conserve memory.  We must loop through\n     * each event and perform the traversal for each one. We cannot perform a\n     * single traversal for the entire collection of events because each event may\n     * have a different target.\n     */\n    function accumulateTwoPhaseDispatchesSingle(event) {\n      if (event && event.dispatchConfig.phasedRegistrationNames) {\n        traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);\n      }\n    }\n\n    /**\n     * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.\n     */\n    function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {\n      if (event && event.dispatchConfig.phasedRegistrationNames) {\n        var targetInst = event._targetInst;\n        var parentInst = targetInst ? getParentInstance(targetInst) : null;\n        traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);\n      }\n    }\n\n    /**\n     * Accumulates without regard to direction, does not look for phased\n     * registration names. Same as `accumulateDirectDispatchesSingle` but without\n     * requiring that the `dispatchMarker` be the same as the dispatched ID.\n     */\n    function accumulateDispatches(inst, ignoredDirection, event) {\n      if (inst && event && event.dispatchConfig.registrationName) {\n        var registrationName = event.dispatchConfig.registrationName;\n        var listener = getListener(inst, registrationName);\n        if (listener) {\n          event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);\n          event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);\n        }\n      }\n    }\n\n    /**\n     * Accumulates dispatches on an `SyntheticEvent`, but only for the\n     * `dispatchMarker`.\n     * @param {SyntheticEvent} event\n     */\n    function accumulateDirectDispatchesSingle(event) {\n      if (event && event.dispatchConfig.registrationName) {\n        accumulateDispatches(event._targetInst, null, event);\n      }\n    }\n\n    function accumulateTwoPhaseDispatches(events) {\n      forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);\n    }\n\n    function accumulateTwoPhaseDispatchesSkipTarget(events) {\n      forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);\n    }\n\n    function accumulateEnterLeaveDispatches(leave, enter, from, to) {\n      traverseEnterLeave(from, to, accumulateDispatches, leave, enter);\n    }\n\n    function accumulateDirectDispatches(events) {\n      forEachAccumulated(events, accumulateDirectDispatchesSingle);\n    }\n\n    var EventPropagators = Object.freeze({\n      accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,\n      accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,\n      accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches,\n      accumulateDirectDispatches: accumulateDirectDispatches\n    });\n\n    var contentKey = null;\n\n    /**\n     * Gets the key used to access text content on a DOM node.\n     *\n     * @return {?string} Key used to access text content.\n     * @internal\n     */\n    function getTextContentAccessor() {\n      if (!contentKey && ExecutionEnvironment.canUseDOM) {\n        // Prefer textContent to innerText because many browsers support both but\n        // SVG <text> elements don't support innerText even when <div> does.\n        contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';\n      }\n      return contentKey;\n    }\n\n    /**\n     * This helper object stores information about text content of a target node,\n     * allowing comparison of content before and after a given event.\n     *\n     * Identify the node where selection currently begins, then observe\n     * both its text content and its current position in the DOM. Since the\n     * browser may natively replace the target node during composition, we can\n     * use its position to find its replacement.\n     *\n     *\n     */\n    var compositionState = {\n      _root: null,\n      _startText: null,\n      _fallbackText: null\n    };\n\n    function initialize(nativeEventTarget) {\n      compositionState._root = nativeEventTarget;\n      compositionState._startText = getText();\n      return true;\n    }\n\n    function reset() {\n      compositionState._root = null;\n      compositionState._startText = null;\n      compositionState._fallbackText = null;\n    }\n\n    function getData() {\n      if (compositionState._fallbackText) {\n        return compositionState._fallbackText;\n      }\n\n      var start;\n      var startValue = compositionState._startText;\n      var startLength = startValue.length;\n      var end;\n      var endValue = getText();\n      var endLength = endValue.length;\n\n      for (start = 0; start < startLength; start++) {\n        if (startValue[start] !== endValue[start]) {\n          break;\n        }\n      }\n\n      var minEnd = startLength - start;\n      for (end = 1; end <= minEnd; end++) {\n        if (startValue[startLength - end] !== endValue[endLength - end]) {\n          break;\n        }\n      }\n\n      var sliceTail = end > 1 ? 1 - end : undefined;\n      compositionState._fallbackText = endValue.slice(start, sliceTail);\n      return compositionState._fallbackText;\n    }\n\n    function getText() {\n      if ('value' in compositionState._root) {\n        return compositionState._root.value;\n      }\n      return compositionState._root[getTextContentAccessor()];\n    }\n\n    /* eslint valid-typeof: 0 */\n\n    var didWarnForAddedNewProperty = false;\n    var isProxySupported = typeof Proxy === 'function';\n    var EVENT_POOL_SIZE = 10;\n\n    var shouldBeReleasedProperties = ['dispatchConfig', '_targetInst', 'nativeEvent', 'isDefaultPrevented', 'isPropagationStopped', '_dispatchListeners', '_dispatchInstances'];\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var EventInterface = {\n      type: null,\n      target: null,\n      // currentTarget is set when dispatching; no use in copying it here\n      currentTarget: emptyFunction.thatReturnsNull,\n      eventPhase: null,\n      bubbles: null,\n      cancelable: null,\n      timeStamp: function (event) {\n        return event.timeStamp || Date.now();\n      },\n      defaultPrevented: null,\n      isTrusted: null\n    };\n\n    /**\n     * Synthetic events are dispatched by event plugins, typically in response to a\n     * top-level event delegation handler.\n     *\n     * These systems should generally use pooling to reduce the frequency of garbage\n     * collection. The system should check `isPersistent` to determine whether the\n     * event should be released into the pool after being dispatched. Users that\n     * need a persisted event should invoke `persist`.\n     *\n     * Synthetic events (and subclasses) implement the DOM Level 3 Events API by\n     * normalizing browser quirks. Subclasses do not necessarily have to implement a\n     * DOM interface; custom application-specific events can also subclass this.\n     *\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {*} targetInst Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @param {DOMEventTarget} nativeEventTarget Target node.\n     */\n    function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {\n      {\n        // these have a getter/setter for warnings\n        delete this.nativeEvent;\n        delete this.preventDefault;\n        delete this.stopPropagation;\n      }\n\n      this.dispatchConfig = dispatchConfig;\n      this._targetInst = targetInst;\n      this.nativeEvent = nativeEvent;\n\n      var Interface = this.constructor.Interface;\n      for (var propName in Interface) {\n        if (!Interface.hasOwnProperty(propName)) {\n          continue;\n        }\n        {\n          delete this[propName]; // this has a getter/setter for warnings\n        }\n        var normalize = Interface[propName];\n        if (normalize) {\n          this[propName] = normalize(nativeEvent);\n        } else {\n          if (propName === 'target') {\n            this.target = nativeEventTarget;\n          } else {\n            this[propName] = nativeEvent[propName];\n          }\n        }\n      }\n\n      var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;\n      if (defaultPrevented) {\n        this.isDefaultPrevented = emptyFunction.thatReturnsTrue;\n      } else {\n        this.isDefaultPrevented = emptyFunction.thatReturnsFalse;\n      }\n      this.isPropagationStopped = emptyFunction.thatReturnsFalse;\n      return this;\n    }\n\n    _assign(SyntheticEvent.prototype, {\n      preventDefault: function () {\n        this.defaultPrevented = true;\n        var event = this.nativeEvent;\n        if (!event) {\n          return;\n        }\n\n        if (event.preventDefault) {\n          event.preventDefault();\n        } else if (typeof event.returnValue !== 'unknown') {\n          event.returnValue = false;\n        }\n        this.isDefaultPrevented = emptyFunction.thatReturnsTrue;\n      },\n\n      stopPropagation: function () {\n        var event = this.nativeEvent;\n        if (!event) {\n          return;\n        }\n\n        if (event.stopPropagation) {\n          event.stopPropagation();\n        } else if (typeof event.cancelBubble !== 'unknown') {\n          // The ChangeEventPlugin registers a \"propertychange\" event for\n          // IE. This event does not support bubbling or cancelling, and\n          // any references to cancelBubble throw \"Member not found\".  A\n          // typeof check of \"unknown\" circumvents this issue (and is also\n          // IE specific).\n          event.cancelBubble = true;\n        }\n\n        this.isPropagationStopped = emptyFunction.thatReturnsTrue;\n      },\n\n      /**\n       * We release all dispatched `SyntheticEvent`s after each event loop, adding\n       * them back into the pool. This allows a way to hold onto a reference that\n       * won't be added back into the pool.\n       */\n      persist: function () {\n        this.isPersistent = emptyFunction.thatReturnsTrue;\n      },\n\n      /**\n       * Checks if this event should be released back into the pool.\n       *\n       * @return {boolean} True if this should not be released, false otherwise.\n       */\n      isPersistent: emptyFunction.thatReturnsFalse,\n\n      /**\n       * `PooledClass` looks for `destructor` on each instance it releases.\n       */\n      destructor: function () {\n        var Interface = this.constructor.Interface;\n        for (var propName in Interface) {\n          {\n            Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));\n          }\n        }\n        for (var i = 0; i < shouldBeReleasedProperties.length; i++) {\n          this[shouldBeReleasedProperties[i]] = null;\n        }\n        {\n          Object.defineProperty(this, 'nativeEvent', getPooledWarningPropertyDefinition('nativeEvent', null));\n          Object.defineProperty(this, 'preventDefault', getPooledWarningPropertyDefinition('preventDefault', emptyFunction));\n          Object.defineProperty(this, 'stopPropagation', getPooledWarningPropertyDefinition('stopPropagation', emptyFunction));\n        }\n      }\n    });\n\n    SyntheticEvent.Interface = EventInterface;\n\n    /**\n     * Helper to reduce boilerplate when creating subclasses.\n     *\n     * @param {function} Class\n     * @param {?object} Interface\n     */\n    SyntheticEvent.augmentClass = function (Class, Interface) {\n      var Super = this;\n\n      var E = function () {};\n      E.prototype = Super.prototype;\n      var prototype = new E();\n\n      _assign(prototype, Class.prototype);\n      Class.prototype = prototype;\n      Class.prototype.constructor = Class;\n\n      Class.Interface = _assign({}, Super.Interface, Interface);\n      Class.augmentClass = Super.augmentClass;\n      addEventPoolingTo(Class);\n    };\n\n    /** Proxying after everything set on SyntheticEvent\n     * to resolve Proxy issue on some WebKit browsers\n     * in which some Event properties are set to undefined (GH#10010)\n     */\n    {\n      if (isProxySupported) {\n        /*eslint-disable no-func-assign */\n        SyntheticEvent = new Proxy(SyntheticEvent, {\n          construct: function (target, args) {\n            return this.apply(target, Object.create(target.prototype), args);\n          },\n          apply: function (constructor, that, args) {\n            return new Proxy(constructor.apply(that, args), {\n              set: function (target, prop, value) {\n                if (prop !== 'isPersistent' && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {\n                  warning(didWarnForAddedNewProperty || target.isPersistent(), \"This synthetic event is reused for performance reasons. If you're \" + \"seeing this, you're adding a new property in the synthetic event object. \" + 'The property is never released. See ' + 'https://fb.me/react-event-pooling for more information.');\n                  didWarnForAddedNewProperty = true;\n                }\n                target[prop] = value;\n                return true;\n              }\n            });\n          }\n        });\n        /*eslint-enable no-func-assign */\n      }\n    }\n\n    addEventPoolingTo(SyntheticEvent);\n\n    /**\n     * Helper to nullify syntheticEvent instance properties when destructing\n     *\n     * @param {String} propName\n     * @param {?object} getVal\n     * @return {object} defineProperty object\n     */\n    function getPooledWarningPropertyDefinition(propName, getVal) {\n      var isFunction = typeof getVal === 'function';\n      return {\n        configurable: true,\n        set: set,\n        get: get\n      };\n\n      function set(val) {\n        var action = isFunction ? 'setting the method' : 'setting the property';\n        warn(action, 'This is effectively a no-op');\n        return val;\n      }\n\n      function get() {\n        var action = isFunction ? 'accessing the method' : 'accessing the property';\n        var result = isFunction ? 'This is a no-op function' : 'This is set to null';\n        warn(action, result);\n        return getVal;\n      }\n\n      function warn(action, result) {\n        var warningCondition = false;\n        warning(warningCondition, \"This synthetic event is reused for performance reasons. If you're seeing this, \" + \"you're %s `%s` on a released/nullified synthetic event. %s. \" + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result);\n      }\n    }\n\n    function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {\n      var EventConstructor = this;\n      if (EventConstructor.eventPool.length) {\n        var instance = EventConstructor.eventPool.pop();\n        EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);\n        return instance;\n      }\n      return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);\n    }\n\n    function releasePooledEvent(event) {\n      var EventConstructor = this;\n      !(event instanceof EventConstructor) ? invariant(false, 'Trying to release an event instance  into a pool of a different type.') : void 0;\n      event.destructor();\n      if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {\n        EventConstructor.eventPool.push(event);\n      }\n    }\n\n    function addEventPoolingTo(EventConstructor) {\n      EventConstructor.eventPool = [];\n      EventConstructor.getPooled = getPooledEvent;\n      EventConstructor.release = releasePooledEvent;\n    }\n\n    var SyntheticEvent$1 = SyntheticEvent;\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents\n     */\n    var CompositionEventInterface = {\n      data: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticCompositionEvent, CompositionEventInterface);\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105\n     *      /#events-inputevents\n     */\n    var InputEventInterface = {\n      data: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticInputEvent, InputEventInterface);\n\n    var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space\n    var START_KEYCODE = 229;\n\n    var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window;\n\n    var documentMode = null;\n    if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) {\n      documentMode = document.documentMode;\n    }\n\n    // Webkit offers a very useful `textInput` event that can be used to\n    // directly represent `beforeInput`. The IE `textinput` event is not as\n    // useful, so we don't use it.\n    var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto();\n\n    // In IE9+, we have access to composition events, but the data supplied\n    // by the native compositionend event may be incorrect. Japanese ideographic\n    // spaces, for instance (\\u3000) are not recorded correctly.\n    var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11);\n\n    /**\n     * Opera <= 12 includes TextEvent in window, but does not fire\n     * text input events. Rely on keypress instead.\n     */\n    function isPresto() {\n      var opera = window.opera;\n      return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12;\n    }\n\n    var SPACEBAR_CODE = 32;\n    var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE);\n\n    // Events and their corresponding property names.\n    var eventTypes = {\n      beforeInput: {\n        phasedRegistrationNames: {\n          bubbled: 'onBeforeInput',\n          captured: 'onBeforeInputCapture'\n        },\n        dependencies: ['topCompositionEnd', 'topKeyPress', 'topTextInput', 'topPaste']\n      },\n      compositionEnd: {\n        phasedRegistrationNames: {\n          bubbled: 'onCompositionEnd',\n          captured: 'onCompositionEndCapture'\n        },\n        dependencies: ['topBlur', 'topCompositionEnd', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']\n      },\n      compositionStart: {\n        phasedRegistrationNames: {\n          bubbled: 'onCompositionStart',\n          captured: 'onCompositionStartCapture'\n        },\n        dependencies: ['topBlur', 'topCompositionStart', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']\n      },\n      compositionUpdate: {\n        phasedRegistrationNames: {\n          bubbled: 'onCompositionUpdate',\n          captured: 'onCompositionUpdateCapture'\n        },\n        dependencies: ['topBlur', 'topCompositionUpdate', 'topKeyDown', 'topKeyPress', 'topKeyUp', 'topMouseDown']\n      }\n    };\n\n    // Track whether we've ever handled a keypress on the space key.\n    var hasSpaceKeypress = false;\n\n    /**\n     * Return whether a native keypress event is assumed to be a command.\n     * This is required because Firefox fires `keypress` events for key commands\n     * (cut, copy, select-all, etc.) even though no character is inserted.\n     */\n    function isKeypressCommand(nativeEvent) {\n      return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) &&\n      // ctrlKey && altKey is equivalent to AltGr, and is not a command.\n      !(nativeEvent.ctrlKey && nativeEvent.altKey);\n    }\n\n    /**\n     * Translate native top level events into event types.\n     *\n     * @param {string} topLevelType\n     * @return {object}\n     */\n    function getCompositionEventType(topLevelType) {\n      switch (topLevelType) {\n        case 'topCompositionStart':\n          return eventTypes.compositionStart;\n        case 'topCompositionEnd':\n          return eventTypes.compositionEnd;\n        case 'topCompositionUpdate':\n          return eventTypes.compositionUpdate;\n      }\n    }\n\n    /**\n     * Does our fallback best-guess model think this event signifies that\n     * composition has begun?\n     *\n     * @param {string} topLevelType\n     * @param {object} nativeEvent\n     * @return {boolean}\n     */\n    function isFallbackCompositionStart(topLevelType, nativeEvent) {\n      return topLevelType === 'topKeyDown' && nativeEvent.keyCode === START_KEYCODE;\n    }\n\n    /**\n     * Does our fallback mode think that this event is the end of composition?\n     *\n     * @param {string} topLevelType\n     * @param {object} nativeEvent\n     * @return {boolean}\n     */\n    function isFallbackCompositionEnd(topLevelType, nativeEvent) {\n      switch (topLevelType) {\n        case 'topKeyUp':\n          // Command keys insert or clear IME input.\n          return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1;\n        case 'topKeyDown':\n          // Expect IME keyCode on each keydown. If we get any other\n          // code we must have exited earlier.\n          return nativeEvent.keyCode !== START_KEYCODE;\n        case 'topKeyPress':\n        case 'topMouseDown':\n        case 'topBlur':\n          // Events are not possible without cancelling IME.\n          return true;\n        default:\n          return false;\n      }\n    }\n\n    /**\n     * Google Input Tools provides composition data via a CustomEvent,\n     * with the `data` property populated in the `detail` object. If this\n     * is available on the event object, use it. If not, this is a plain\n     * composition event and we have nothing special to extract.\n     *\n     * @param {object} nativeEvent\n     * @return {?string}\n     */\n    function getDataFromCustomEvent(nativeEvent) {\n      var detail = nativeEvent.detail;\n      if (typeof detail === 'object' && 'data' in detail) {\n        return detail.data;\n      }\n      return null;\n    }\n\n    // Track the current IME composition status, if any.\n    var isComposing = false;\n\n    /**\n     * @return {?object} A SyntheticCompositionEvent.\n     */\n    function extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n      var eventType;\n      var fallbackData;\n\n      if (canUseCompositionEvent) {\n        eventType = getCompositionEventType(topLevelType);\n      } else if (!isComposing) {\n        if (isFallbackCompositionStart(topLevelType, nativeEvent)) {\n          eventType = eventTypes.compositionStart;\n        }\n      } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) {\n        eventType = eventTypes.compositionEnd;\n      }\n\n      if (!eventType) {\n        return null;\n      }\n\n      if (useFallbackCompositionData) {\n        // The current composition is stored statically and must not be\n        // overwritten while composition continues.\n        if (!isComposing && eventType === eventTypes.compositionStart) {\n          isComposing = initialize(nativeEventTarget);\n        } else if (eventType === eventTypes.compositionEnd) {\n          if (isComposing) {\n            fallbackData = getData();\n          }\n        }\n      }\n\n      var event = SyntheticCompositionEvent.getPooled(eventType, targetInst, nativeEvent, nativeEventTarget);\n\n      if (fallbackData) {\n        // Inject data generated from fallback path into the synthetic event.\n        // This matches the property of native CompositionEventInterface.\n        event.data = fallbackData;\n      } else {\n        var customData = getDataFromCustomEvent(nativeEvent);\n        if (customData !== null) {\n          event.data = customData;\n        }\n      }\n\n      accumulateTwoPhaseDispatches(event);\n      return event;\n    }\n\n    /**\n     * @param {TopLevelTypes} topLevelType Record from `BrowserEventConstants`.\n     * @param {object} nativeEvent Native browser event.\n     * @return {?string} The string corresponding to this `beforeInput` event.\n     */\n    function getNativeBeforeInputChars(topLevelType, nativeEvent) {\n      switch (topLevelType) {\n        case 'topCompositionEnd':\n          return getDataFromCustomEvent(nativeEvent);\n        case 'topKeyPress':\n          /**\n           * If native `textInput` events are available, our goal is to make\n           * use of them. However, there is a special case: the spacebar key.\n           * In Webkit, preventing default on a spacebar `textInput` event\n           * cancels character insertion, but it *also* causes the browser\n           * to fall back to its default spacebar behavior of scrolling the\n           * page.\n           *\n           * Tracking at:\n           * https://code.google.com/p/chromium/issues/detail?id=355103\n           *\n           * To avoid this issue, use the keypress event as if no `textInput`\n           * event is available.\n           */\n          var which = nativeEvent.which;\n          if (which !== SPACEBAR_CODE) {\n            return null;\n          }\n\n          hasSpaceKeypress = true;\n          return SPACEBAR_CHAR;\n\n        case 'topTextInput':\n          // Record the characters to be added to the DOM.\n          var chars = nativeEvent.data;\n\n          // If it's a spacebar character, assume that we have already handled\n          // it at the keypress level and bail immediately. Android Chrome\n          // doesn't give us keycodes, so we need to blacklist it.\n          if (chars === SPACEBAR_CHAR && hasSpaceKeypress) {\n            return null;\n          }\n\n          return chars;\n\n        default:\n          // For other native event types, do nothing.\n          return null;\n      }\n    }\n\n    /**\n     * For browsers that do not provide the `textInput` event, extract the\n     * appropriate string to use for SyntheticInputEvent.\n     *\n     * @param {string} topLevelType Record from `BrowserEventConstants`.\n     * @param {object} nativeEvent Native browser event.\n     * @return {?string} The fallback string for this `beforeInput` event.\n     */\n    function getFallbackBeforeInputChars(topLevelType, nativeEvent) {\n      // If we are currently composing (IME) and using a fallback to do so,\n      // try to extract the composed characters from the fallback object.\n      // If composition event is available, we extract a string only at\n      // compositionevent, otherwise extract it at fallback events.\n      if (isComposing) {\n        if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) {\n          var chars = getData();\n          reset();\n          isComposing = false;\n          return chars;\n        }\n        return null;\n      }\n\n      switch (topLevelType) {\n        case 'topPaste':\n          // If a paste event occurs after a keypress, throw out the input\n          // chars. Paste events should not lead to BeforeInput events.\n          return null;\n        case 'topKeyPress':\n          /**\n           * As of v27, Firefox may fire keypress events even when no character\n           * will be inserted. A few possibilities:\n           *\n           * - `which` is `0`. Arrow keys, Esc key, etc.\n           *\n           * - `which` is the pressed key code, but no char is available.\n           *   Ex: 'AltGr + d` in Polish. There is no modified character for\n           *   this key combination and no character is inserted into the\n           *   document, but FF fires the keypress for char code `100` anyway.\n           *   No `input` event will occur.\n           *\n           * - `which` is the pressed key code, but a command combination is\n           *   being used. Ex: `Cmd+C`. No character is inserted, and no\n           *   `input` event will occur.\n           */\n          if (!isKeypressCommand(nativeEvent)) {\n            // IE fires the `keypress` event when a user types an emoji via\n            // Touch keyboard of Windows.  In such a case, the `char` property\n            // holds an emoji character like `\\uD83D\\uDE0A`.  Because its length\n            // is 2, the property `which` does not represent an emoji correctly.\n            // In such a case, we directly return the `char` property instead of\n            // using `which`.\n            if (nativeEvent.char && nativeEvent.char.length > 1) {\n              return nativeEvent.char;\n            } else if (nativeEvent.which) {\n              return String.fromCharCode(nativeEvent.which);\n            }\n          }\n          return null;\n        case 'topCompositionEnd':\n          return useFallbackCompositionData ? null : nativeEvent.data;\n        default:\n          return null;\n      }\n    }\n\n    /**\n     * Extract a SyntheticInputEvent for `beforeInput`, based on either native\n     * `textInput` or fallback behavior.\n     *\n     * @return {?object} A SyntheticInputEvent.\n     */\n    function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n      var chars;\n\n      if (canUseTextInputEvent) {\n        chars = getNativeBeforeInputChars(topLevelType, nativeEvent);\n      } else {\n        chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);\n      }\n\n      // If no characters are being inserted, no BeforeInput event should\n      // be fired.\n      if (!chars) {\n        return null;\n      }\n\n      var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);\n\n      event.data = chars;\n      accumulateTwoPhaseDispatches(event);\n      return event;\n    }\n\n    /**\n     * Create an `onBeforeInput` event to match\n     * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents.\n     *\n     * This event plugin is based on the native `textInput` event\n     * available in Chrome, Safari, Opera, and IE. This event fires after\n     * `onKeyPress` and `onCompositionEnd`, but before `onInput`.\n     *\n     * `beforeInput` is spec'd but not implemented in any browsers, and\n     * the `input` event does not provide any useful information about what has\n     * actually been added, contrary to the spec. Thus, `textInput` is the best\n     * available event to identify the characters that have actually been inserted\n     * into the target node.\n     *\n     * This plugin is also responsible for emitting `composition` events, thus\n     * allowing us to share composition fallback code for both `beforeInput` and\n     * `composition` event types.\n     */\n    var BeforeInputEventPlugin = {\n      eventTypes: eventTypes,\n\n      extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n        return [extractCompositionEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget)];\n      }\n    };\n\n    // Use to restore controlled state after a change event has fired.\n\n    var fiberHostComponent = null;\n\n    var ReactControlledComponentInjection = {\n      injectFiberControlledHostComponent: function (hostComponentImpl) {\n        // The fiber implementation doesn't use dynamic dispatch so we need to\n        // inject the implementation.\n        fiberHostComponent = hostComponentImpl;\n      }\n    };\n\n    var restoreTarget = null;\n    var restoreQueue = null;\n\n    function restoreStateOfTarget(target) {\n      // We perform this translation at the end of the event loop so that we\n      // always receive the correct fiber here\n      var internalInstance = getInstanceFromNode(target);\n      if (!internalInstance) {\n        // Unmounted\n        return;\n      }\n      !(fiberHostComponent && typeof fiberHostComponent.restoreControlledState === 'function') ? invariant(false, 'Fiber needs to be injected to handle a fiber target for controlled events. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n      var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);\n      fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);\n    }\n\n    var injection$3 = ReactControlledComponentInjection;\n\n    function enqueueStateRestore(target) {\n      if (restoreTarget) {\n        if (restoreQueue) {\n          restoreQueue.push(target);\n        } else {\n          restoreQueue = [target];\n        }\n      } else {\n        restoreTarget = target;\n      }\n    }\n\n    function restoreStateIfNeeded() {\n      if (!restoreTarget) {\n        return;\n      }\n      var target = restoreTarget;\n      var queuedTargets = restoreQueue;\n      restoreTarget = null;\n      restoreQueue = null;\n\n      restoreStateOfTarget(target);\n      if (queuedTargets) {\n        for (var i = 0; i < queuedTargets.length; i++) {\n          restoreStateOfTarget(queuedTargets[i]);\n        }\n      }\n    }\n\n    var ReactControlledComponent = Object.freeze({\n      injection: injection$3,\n      enqueueStateRestore: enqueueStateRestore,\n      restoreStateIfNeeded: restoreStateIfNeeded\n    });\n\n    // Used as a way to call batchedUpdates when we don't have a reference to\n    // the renderer. Such as when we're dispatching events or if third party\n    // libraries need to call batchedUpdates. Eventually, this API will go away when\n    // everything is batched by default. We'll then have a similar API to opt-out of\n    // scheduled work and instead do synchronous work.\n\n    // Defaults\n    var fiberBatchedUpdates = function (fn, bookkeeping) {\n      return fn(bookkeeping);\n    };\n\n    var isNestingBatched = false;\n    function batchedUpdates(fn, bookkeeping) {\n      if (isNestingBatched) {\n        // If we are currently inside another batch, we need to wait until it\n        // fully completes before restoring state. Therefore, we add the target to\n        // a queue of work.\n        return fiberBatchedUpdates(fn, bookkeeping);\n      }\n      isNestingBatched = true;\n      try {\n        return fiberBatchedUpdates(fn, bookkeeping);\n      } finally {\n        // Here we wait until all updates have propagated, which is important\n        // when using controlled components within layers:\n        // https://github.com/facebook/react/issues/1698\n        // Then we restore state of any controlled component.\n        isNestingBatched = false;\n        restoreStateIfNeeded();\n      }\n    }\n\n    var ReactGenericBatchingInjection = {\n      injectFiberBatchedUpdates: function (_batchedUpdates) {\n        fiberBatchedUpdates = _batchedUpdates;\n      }\n    };\n\n    var injection$4 = ReactGenericBatchingInjection;\n\n    /**\n     * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary\n     */\n    var supportedInputTypes = {\n      color: true,\n      date: true,\n      datetime: true,\n      'datetime-local': true,\n      email: true,\n      month: true,\n      number: true,\n      password: true,\n      range: true,\n      search: true,\n      tel: true,\n      text: true,\n      time: true,\n      url: true,\n      week: true\n    };\n\n    function isTextInputElement(elem) {\n      var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n\n      if (nodeName === 'input') {\n        return !!supportedInputTypes[elem.type];\n      }\n\n      if (nodeName === 'textarea') {\n        return true;\n      }\n\n      return false;\n    }\n\n    /**\n     * HTML nodeType values that represent the type of the node\n     */\n\n    var ELEMENT_NODE = 1;\n    var TEXT_NODE = 3;\n    var COMMENT_NODE = 8;\n    var DOCUMENT_NODE = 9;\n    var DOCUMENT_FRAGMENT_NODE = 11;\n\n    /**\n     * Gets the target node from a native browser event by accounting for\n     * inconsistencies in browser DOM APIs.\n     *\n     * @param {object} nativeEvent Native browser event.\n     * @return {DOMEventTarget} Target node.\n     */\n    function getEventTarget(nativeEvent) {\n      var target = nativeEvent.target || nativeEvent.srcElement || window;\n\n      // Normalize SVG <use> element events #4963\n      if (target.correspondingUseElement) {\n        target = target.correspondingUseElement;\n      }\n\n      // Safari may fire events on text nodes (Node.TEXT_NODE is 3).\n      // @see http://www.quirksmode.org/js/events_properties.html\n      return target.nodeType === TEXT_NODE ? target.parentNode : target;\n    }\n\n    var useHasFeature;\n    if (ExecutionEnvironment.canUseDOM) {\n      useHasFeature = document.implementation && document.implementation.hasFeature &&\n      // always returns true in newer browsers as per the standard.\n      // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature\n      document.implementation.hasFeature('', '') !== true;\n    }\n\n    /**\n     * Checks if an event is supported in the current execution environment.\n     *\n     * NOTE: This will not work correctly for non-generic events such as `change`,\n     * `reset`, `load`, `error`, and `select`.\n     *\n     * Borrows from Modernizr.\n     *\n     * @param {string} eventNameSuffix Event name, e.g. \"click\".\n     * @param {?boolean} capture Check if the capture phase is supported.\n     * @return {boolean} True if the event is supported.\n     * @internal\n     * @license Modernizr 3.0.0pre (Custom Build) | MIT\n     */\n    function isEventSupported(eventNameSuffix, capture) {\n      if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) {\n        return false;\n      }\n\n      var eventName = 'on' + eventNameSuffix;\n      var isSupported = eventName in document;\n\n      if (!isSupported) {\n        var element = document.createElement('div');\n        element.setAttribute(eventName, 'return;');\n        isSupported = typeof element[eventName] === 'function';\n      }\n\n      if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') {\n        // This is the only way to test support for the `wheel` event in IE9+.\n        isSupported = document.implementation.hasFeature('Events.wheel', '3.0');\n      }\n\n      return isSupported;\n    }\n\n    function isCheckable(elem) {\n      var type = elem.type;\n      var nodeName = elem.nodeName;\n      return nodeName && nodeName.toLowerCase() === 'input' && (type === 'checkbox' || type === 'radio');\n    }\n\n    function getTracker(node) {\n      return node._valueTracker;\n    }\n\n    function detachTracker(node) {\n      node._valueTracker = null;\n    }\n\n    function getValueFromNode(node) {\n      var value = '';\n      if (!node) {\n        return value;\n      }\n\n      if (isCheckable(node)) {\n        value = node.checked ? 'true' : 'false';\n      } else {\n        value = node.value;\n      }\n\n      return value;\n    }\n\n    function trackValueOnNode(node) {\n      var valueField = isCheckable(node) ? 'checked' : 'value';\n      var descriptor = Object.getOwnPropertyDescriptor(node.constructor.prototype, valueField);\n\n      var currentValue = '' + node[valueField];\n\n      // if someone has already defined a value or Safari, then bail\n      // and don't track value will cause over reporting of changes,\n      // but it's better then a hard failure\n      // (needed for certain tests that spyOn input values and Safari)\n      if (node.hasOwnProperty(valueField) || typeof descriptor.get !== 'function' || typeof descriptor.set !== 'function') {\n        return;\n      }\n\n      Object.defineProperty(node, valueField, {\n        enumerable: descriptor.enumerable,\n        configurable: true,\n        get: function () {\n          return descriptor.get.call(this);\n        },\n        set: function (value) {\n          currentValue = '' + value;\n          descriptor.set.call(this, value);\n        }\n      });\n\n      var tracker = {\n        getValue: function () {\n          return currentValue;\n        },\n        setValue: function (value) {\n          currentValue = '' + value;\n        },\n        stopTracking: function () {\n          detachTracker(node);\n          delete node[valueField];\n        }\n      };\n      return tracker;\n    }\n\n    function track(node) {\n      if (getTracker(node)) {\n        return;\n      }\n\n      // TODO: Once it's just Fiber we can move this to node._wrapperState\n      node._valueTracker = trackValueOnNode(node);\n    }\n\n    function updateValueIfChanged(node) {\n      if (!node) {\n        return false;\n      }\n\n      var tracker = getTracker(node);\n      // if there is no tracker at this point it's unlikely\n      // that trying again will succeed\n      if (!tracker) {\n        return true;\n      }\n\n      var lastValue = tracker.getValue();\n      var nextValue = getValueFromNode(node);\n      if (nextValue !== lastValue) {\n        tracker.setValue(nextValue);\n        return true;\n      }\n      return false;\n    }\n\n    var eventTypes$1 = {\n      change: {\n        phasedRegistrationNames: {\n          bubbled: 'onChange',\n          captured: 'onChangeCapture'\n        },\n        dependencies: ['topBlur', 'topChange', 'topClick', 'topFocus', 'topInput', 'topKeyDown', 'topKeyUp', 'topSelectionChange']\n      }\n    };\n\n    function createAndAccumulateChangeEvent(inst, nativeEvent, target) {\n      var event = SyntheticEvent$1.getPooled(eventTypes$1.change, inst, nativeEvent, target);\n      event.type = 'change';\n      // Flag this event loop as needing state restore.\n      enqueueStateRestore(target);\n      accumulateTwoPhaseDispatches(event);\n      return event;\n    }\n    /**\n     * For IE shims\n     */\n    var activeElement = null;\n    var activeElementInst = null;\n\n    /**\n     * SECTION: handle `change` event\n     */\n    function shouldUseChangeEvent(elem) {\n      var nodeName = elem.nodeName && elem.nodeName.toLowerCase();\n      return nodeName === 'select' || nodeName === 'input' && elem.type === 'file';\n    }\n\n    function manualDispatchChangeEvent(nativeEvent) {\n      var event = createAndAccumulateChangeEvent(activeElementInst, nativeEvent, getEventTarget(nativeEvent));\n\n      // If change and propertychange bubbled, we'd just bind to it like all the\n      // other events and have it go through ReactBrowserEventEmitter. Since it\n      // doesn't, we manually listen for the events and so we have to enqueue and\n      // process the abstract event manually.\n      //\n      // Batching is necessary here in order to ensure that all event handlers run\n      // before the next rerender (including event handlers attached to ancestor\n      // elements instead of directly on the input). Without this, controlled\n      // components don't work properly in conjunction with event bubbling because\n      // the component is rerendered and the value reverted before all the event\n      // handlers can run. See https://github.com/facebook/react/issues/708.\n      batchedUpdates(runEventInBatch, event);\n    }\n\n    function runEventInBatch(event) {\n      enqueueEvents(event);\n      processEventQueue(false);\n    }\n\n    function getInstIfValueChanged(targetInst) {\n      var targetNode = getNodeFromInstance$1(targetInst);\n      if (updateValueIfChanged(targetNode)) {\n        return targetInst;\n      }\n    }\n\n    function getTargetInstForChangeEvent(topLevelType, targetInst) {\n      if (topLevelType === 'topChange') {\n        return targetInst;\n      }\n    }\n\n    /**\n     * SECTION: handle `input` event\n     */\n    var isInputEventSupported = false;\n    if (ExecutionEnvironment.canUseDOM) {\n      // IE9 claims to support the input event but fails to trigger it when\n      // deleting text, so we ignore its input events.\n      isInputEventSupported = isEventSupported('input') && (!document.documentMode || document.documentMode > 9);\n    }\n\n    /**\n     * (For IE <=9) Starts tracking propertychange events on the passed-in element\n     * and override the value property so that we can distinguish user events from\n     * value changes in JS.\n     */\n    function startWatchingForValueChange(target, targetInst) {\n      activeElement = target;\n      activeElementInst = targetInst;\n      activeElement.attachEvent('onpropertychange', handlePropertyChange);\n    }\n\n    /**\n     * (For IE <=9) Removes the event listeners from the currently-tracked element,\n     * if any exists.\n     */\n    function stopWatchingForValueChange() {\n      if (!activeElement) {\n        return;\n      }\n      activeElement.detachEvent('onpropertychange', handlePropertyChange);\n      activeElement = null;\n      activeElementInst = null;\n    }\n\n    /**\n     * (For IE <=9) Handles a propertychange event, sending a `change` event if\n     * the value of the active element has changed.\n     */\n    function handlePropertyChange(nativeEvent) {\n      if (nativeEvent.propertyName !== 'value') {\n        return;\n      }\n      if (getInstIfValueChanged(activeElementInst)) {\n        manualDispatchChangeEvent(nativeEvent);\n      }\n    }\n\n    function handleEventsForInputEventPolyfill(topLevelType, target, targetInst) {\n      if (topLevelType === 'topFocus') {\n        // In IE9, propertychange fires for most input events but is buggy and\n        // doesn't fire when text is deleted, but conveniently, selectionchange\n        // appears to fire in all of the remaining cases so we catch those and\n        // forward the event if the value has changed\n        // In either case, we don't want to call the event handler if the value\n        // is changed from JS so we redefine a setter for `.value` that updates\n        // our activeElementValue variable, allowing us to ignore those changes\n        //\n        // stopWatching() should be a noop here but we call it just in case we\n        // missed a blur event somehow.\n        stopWatchingForValueChange();\n        startWatchingForValueChange(target, targetInst);\n      } else if (topLevelType === 'topBlur') {\n        stopWatchingForValueChange();\n      }\n    }\n\n    // For IE8 and IE9.\n    function getTargetInstForInputEventPolyfill(topLevelType, targetInst) {\n      if (topLevelType === 'topSelectionChange' || topLevelType === 'topKeyUp' || topLevelType === 'topKeyDown') {\n        // On the selectionchange event, the target is just document which isn't\n        // helpful for us so just check activeElement instead.\n        //\n        // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire\n        // propertychange on the first input event after setting `value` from a\n        // script and fires only keydown, keypress, keyup. Catching keyup usually\n        // gets it and catching keydown lets us fire an event for the first\n        // keystroke if user does a key repeat (it'll be a little delayed: right\n        // before the second keystroke). Other input methods (e.g., paste) seem to\n        // fire selectionchange normally.\n        return getInstIfValueChanged(activeElementInst);\n      }\n    }\n\n    /**\n     * SECTION: handle `click` event\n     */\n    function shouldUseClickEvent(elem) {\n      // Use the `click` event to detect changes to checkbox and radio inputs.\n      // This approach works across all browsers, whereas `change` does not fire\n      // until `blur` in IE8.\n      var nodeName = elem.nodeName;\n      return nodeName && nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio');\n    }\n\n    function getTargetInstForClickEvent(topLevelType, targetInst) {\n      if (topLevelType === 'topClick') {\n        return getInstIfValueChanged(targetInst);\n      }\n    }\n\n    function getTargetInstForInputOrChangeEvent(topLevelType, targetInst) {\n      if (topLevelType === 'topInput' || topLevelType === 'topChange') {\n        return getInstIfValueChanged(targetInst);\n      }\n    }\n\n    function handleControlledInputBlur(inst, node) {\n      // TODO: In IE, inst is occasionally null. Why?\n      if (inst == null) {\n        return;\n      }\n\n      // Fiber and ReactDOM keep wrapper state in separate places\n      var state = inst._wrapperState || node._wrapperState;\n\n      if (!state || !state.controlled || node.type !== 'number') {\n        return;\n      }\n\n      // If controlled, assign the value attribute to the current value on blur\n      var value = '' + node.value;\n      if (node.getAttribute('value') !== value) {\n        node.setAttribute('value', value);\n      }\n    }\n\n    /**\n     * This plugin creates an `onChange` event that normalizes change events\n     * across form elements. This event fires at a time when it's possible to\n     * change the element's value without seeing a flicker.\n     *\n     * Supported elements are:\n     * - input (see `isTextInputElement`)\n     * - textarea\n     * - select\n     */\n    var ChangeEventPlugin = {\n      eventTypes: eventTypes$1,\n\n      _isInputEventSupported: isInputEventSupported,\n\n      extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n        var targetNode = targetInst ? getNodeFromInstance$1(targetInst) : window;\n\n        var getTargetInstFunc, handleEventFunc;\n        if (shouldUseChangeEvent(targetNode)) {\n          getTargetInstFunc = getTargetInstForChangeEvent;\n        } else if (isTextInputElement(targetNode)) {\n          if (isInputEventSupported) {\n            getTargetInstFunc = getTargetInstForInputOrChangeEvent;\n          } else {\n            getTargetInstFunc = getTargetInstForInputEventPolyfill;\n            handleEventFunc = handleEventsForInputEventPolyfill;\n          }\n        } else if (shouldUseClickEvent(targetNode)) {\n          getTargetInstFunc = getTargetInstForClickEvent;\n        }\n\n        if (getTargetInstFunc) {\n          var inst = getTargetInstFunc(topLevelType, targetInst);\n          if (inst) {\n            var event = createAndAccumulateChangeEvent(inst, nativeEvent, nativeEventTarget);\n            return event;\n          }\n        }\n\n        if (handleEventFunc) {\n          handleEventFunc(topLevelType, targetNode, targetInst);\n        }\n\n        // When blurring, set the value attribute for number inputs\n        if (topLevelType === 'topBlur') {\n          handleControlledInputBlur(targetInst, targetNode);\n        }\n      }\n    };\n\n    /**\n     * Module that is injectable into `EventPluginHub`, that specifies a\n     * deterministic ordering of `EventPlugin`s. A convenient way to reason about\n     * plugins, without having to package every one of them. This is better than\n     * having plugins be ordered in the same order that they are injected because\n     * that ordering would be influenced by the packaging order.\n     * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that\n     * preventing default on events is convenient in `SimpleEventPlugin` handlers.\n     */\n    var DOMEventPluginOrder = ['ResponderEventPlugin', 'SimpleEventPlugin', 'TapEventPlugin', 'EnterLeaveEventPlugin', 'ChangeEventPlugin', 'SelectEventPlugin', 'BeforeInputEventPlugin'];\n\n    /**\n     * @interface UIEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var UIEventInterface = {\n      view: null,\n      detail: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticUIEvent, UIEventInterface);\n\n    /**\n     * Translation from modifier key to the associated property in the event.\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers\n     */\n\n    var modifierKeyToProp = {\n      Alt: 'altKey',\n      Control: 'ctrlKey',\n      Meta: 'metaKey',\n      Shift: 'shiftKey'\n    };\n\n    // IE8 does not implement getModifierState so we simply map it to the only\n    // modifier keys exposed by the event itself, does not support Lock-keys.\n    // Currently, all major browsers except Chrome seems to support Lock-keys.\n    function modifierStateGetter(keyArg) {\n      var syntheticEvent = this;\n      var nativeEvent = syntheticEvent.nativeEvent;\n      if (nativeEvent.getModifierState) {\n        return nativeEvent.getModifierState(keyArg);\n      }\n      var keyProp = modifierKeyToProp[keyArg];\n      return keyProp ? !!nativeEvent[keyProp] : false;\n    }\n\n    function getEventModifierState(nativeEvent) {\n      return modifierStateGetter;\n    }\n\n    /**\n     * @interface MouseEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var MouseEventInterface = {\n      screenX: null,\n      screenY: null,\n      clientX: null,\n      clientY: null,\n      pageX: null,\n      pageY: null,\n      ctrlKey: null,\n      shiftKey: null,\n      altKey: null,\n      metaKey: null,\n      getModifierState: getEventModifierState,\n      button: null,\n      buttons: null,\n      relatedTarget: function (event) {\n        return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement);\n      }\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticUIEvent}\n     */\n    function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface);\n\n    var eventTypes$2 = {\n      mouseEnter: {\n        registrationName: 'onMouseEnter',\n        dependencies: ['topMouseOut', 'topMouseOver']\n      },\n      mouseLeave: {\n        registrationName: 'onMouseLeave',\n        dependencies: ['topMouseOut', 'topMouseOver']\n      }\n    };\n\n    var EnterLeaveEventPlugin = {\n      eventTypes: eventTypes$2,\n\n      /**\n       * For almost every interaction we care about, there will be both a top-level\n       * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that\n       * we do not extract duplicate events. However, moving the mouse into the\n       * browser from outside will not fire a `mouseout` event. In this case, we use\n       * the `mouseover` top-level event.\n       */\n      extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n        if (topLevelType === 'topMouseOver' && (nativeEvent.relatedTarget || nativeEvent.fromElement)) {\n          return null;\n        }\n        if (topLevelType !== 'topMouseOut' && topLevelType !== 'topMouseOver') {\n          // Must not be a mouse in or mouse out - ignoring.\n          return null;\n        }\n\n        var win;\n        if (nativeEventTarget.window === nativeEventTarget) {\n          // `nativeEventTarget` is probably a window object.\n          win = nativeEventTarget;\n        } else {\n          // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8.\n          var doc = nativeEventTarget.ownerDocument;\n          if (doc) {\n            win = doc.defaultView || doc.parentWindow;\n          } else {\n            win = window;\n          }\n        }\n\n        var from;\n        var to;\n        if (topLevelType === 'topMouseOut') {\n          from = targetInst;\n          var related = nativeEvent.relatedTarget || nativeEvent.toElement;\n          to = related ? getClosestInstanceFromNode(related) : null;\n        } else {\n          // Moving to a node from outside the window.\n          from = null;\n          to = targetInst;\n        }\n\n        if (from === to) {\n          // Nothing pertains to our managed components.\n          return null;\n        }\n\n        var fromNode = from == null ? win : getNodeFromInstance$1(from);\n        var toNode = to == null ? win : getNodeFromInstance$1(to);\n\n        var leave = SyntheticMouseEvent.getPooled(eventTypes$2.mouseLeave, from, nativeEvent, nativeEventTarget);\n        leave.type = 'mouseleave';\n        leave.target = fromNode;\n        leave.relatedTarget = toNode;\n\n        var enter = SyntheticMouseEvent.getPooled(eventTypes$2.mouseEnter, to, nativeEvent, nativeEventTarget);\n        enter.type = 'mouseenter';\n        enter.target = toNode;\n        enter.relatedTarget = fromNode;\n\n        accumulateEnterLeaveDispatches(leave, enter, from, to);\n\n        return [leave, enter];\n      }\n    };\n\n    /**\n     * `ReactInstanceMap` maintains a mapping from a public facing stateful\n     * instance (key) and the internal representation (value). This allows public\n     * methods to accept the user facing instance as an argument and map them back\n     * to internal methods.\n     *\n     * Note that this module is currently shared and assumed to be stateless.\n     * If this becomes an actual Map, that will break.\n     */\n\n    /**\n     * This API should be called `delete` but we'd have to make sure to always\n     * transform these to strings for IE support. When this transform is fully\n     * supported we can rename it.\n     */\n\n    function get(key) {\n      return key._reactInternalFiber;\n    }\n\n    function has(key) {\n      return key._reactInternalFiber !== undefined;\n    }\n\n    function set(key, value) {\n      key._reactInternalFiber = value;\n    }\n\n    var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n\n    var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;\n    var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;\n\n    function getComponentName(fiber) {\n      var type = fiber.type;\n\n      if (typeof type === 'string') {\n        return type;\n      }\n      if (typeof type === 'function') {\n        return type.displayName || type.name;\n      }\n      return null;\n    }\n\n    // Don't change these two values:\n    var NoEffect = 0; //           0b00000000\n    var PerformedWork = 1; //      0b00000001\n\n    // You can change the rest (and add more).\n    var Placement = 2; //          0b00000010\n    var Update = 4; //             0b00000100\n    var PlacementAndUpdate = 6; // 0b00000110\n    var Deletion = 8; //           0b00001000\n    var ContentReset = 16; //      0b00010000\n    var Callback = 32; //          0b00100000\n    var Err = 64; //               0b01000000\n    var Ref = 128; //              0b10000000\n\n    var MOUNTING = 1;\n    var MOUNTED = 2;\n    var UNMOUNTED = 3;\n\n    function isFiberMountedImpl(fiber) {\n      var node = fiber;\n      if (!fiber.alternate) {\n        // If there is no alternate, this might be a new tree that isn't inserted\n        // yet. If it is, then it will have a pending insertion effect on it.\n        if ((node.effectTag & Placement) !== NoEffect) {\n          return MOUNTING;\n        }\n        while (node['return']) {\n          node = node['return'];\n          if ((node.effectTag & Placement) !== NoEffect) {\n            return MOUNTING;\n          }\n        }\n      } else {\n        while (node['return']) {\n          node = node['return'];\n        }\n      }\n      if (node.tag === HostRoot) {\n        // TODO: Check if this was a nested HostRoot when used with\n        // renderContainerIntoSubtree.\n        return MOUNTED;\n      }\n      // If we didn't hit the root, that means that we're in an disconnected tree\n      // that has been unmounted.\n      return UNMOUNTED;\n    }\n\n    function isFiberMounted(fiber) {\n      return isFiberMountedImpl(fiber) === MOUNTED;\n    }\n\n    function isMounted(component) {\n      {\n        var owner = ReactCurrentOwner.current;\n        if (owner !== null && owner.tag === ClassComponent) {\n          var ownerFiber = owner;\n          var instance = ownerFiber.stateNode;\n          warning(instance._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', getComponentName(ownerFiber) || 'A component');\n          instance._warnedAboutRefsInRender = true;\n        }\n      }\n\n      var fiber = get(component);\n      if (!fiber) {\n        return false;\n      }\n      return isFiberMountedImpl(fiber) === MOUNTED;\n    }\n\n    function assertIsMounted(fiber) {\n      !(isFiberMountedImpl(fiber) === MOUNTED) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;\n    }\n\n    function findCurrentFiberUsingSlowPath(fiber) {\n      var alternate = fiber.alternate;\n      if (!alternate) {\n        // If there is no alternate, then we only need to check if it is mounted.\n        var state = isFiberMountedImpl(fiber);\n        !(state !== UNMOUNTED) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;\n        if (state === MOUNTING) {\n          return null;\n        }\n        return fiber;\n      }\n      // If we have two possible branches, we'll walk backwards up to the root\n      // to see what path the root points to. On the way we may hit one of the\n      // special cases and we'll deal with them.\n      var a = fiber;\n      var b = alternate;\n      while (true) {\n        var parentA = a['return'];\n        var parentB = parentA ? parentA.alternate : null;\n        if (!parentA || !parentB) {\n          // We're at the root.\n          break;\n        }\n\n        // If both copies of the parent fiber point to the same child, we can\n        // assume that the child is current. This happens when we bailout on low\n        // priority: the bailed out fiber's child reuses the current child.\n        if (parentA.child === parentB.child) {\n          var child = parentA.child;\n          while (child) {\n            if (child === a) {\n              // We've determined that A is the current branch.\n              assertIsMounted(parentA);\n              return fiber;\n            }\n            if (child === b) {\n              // We've determined that B is the current branch.\n              assertIsMounted(parentA);\n              return alternate;\n            }\n            child = child.sibling;\n          }\n          // We should never have an alternate for any mounting node. So the only\n          // way this could possibly happen is if this was unmounted, if at all.\n          invariant(false, 'Unable to find node on an unmounted component.');\n        }\n\n        if (a['return'] !== b['return']) {\n          // The return pointer of A and the return pointer of B point to different\n          // fibers. We assume that return pointers never criss-cross, so A must\n          // belong to the child set of A.return, and B must belong to the child\n          // set of B.return.\n          a = parentA;\n          b = parentB;\n        } else {\n          // The return pointers point to the same fiber. We'll have to use the\n          // default, slow path: scan the child sets of each parent alternate to see\n          // which child belongs to which set.\n          //\n          // Search parent A's child set\n          var didFindChild = false;\n          var _child = parentA.child;\n          while (_child) {\n            if (_child === a) {\n              didFindChild = true;\n              a = parentA;\n              b = parentB;\n              break;\n            }\n            if (_child === b) {\n              didFindChild = true;\n              b = parentA;\n              a = parentB;\n              break;\n            }\n            _child = _child.sibling;\n          }\n          if (!didFindChild) {\n            // Search parent B's child set\n            _child = parentB.child;\n            while (_child) {\n              if (_child === a) {\n                didFindChild = true;\n                a = parentB;\n                b = parentA;\n                break;\n              }\n              if (_child === b) {\n                didFindChild = true;\n                b = parentB;\n                a = parentA;\n                break;\n              }\n              _child = _child.sibling;\n            }\n            !didFindChild ? invariant(false, 'Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.') : void 0;\n          }\n        }\n\n        !(a.alternate === b) ? invariant(false, 'Return fibers should always be each others\\' alternates. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n      }\n      // If the root is not a host container, we're in a disconnected tree. I.e.\n      // unmounted.\n      !(a.tag === HostRoot) ? invariant(false, 'Unable to find node on an unmounted component.') : void 0;\n      if (a.stateNode.current === a) {\n        // We've determined that A is the current branch.\n        return fiber;\n      }\n      // Otherwise B has to be current branch.\n      return alternate;\n    }\n\n    function findCurrentHostFiber(parent) {\n      var currentParent = findCurrentFiberUsingSlowPath(parent);\n      if (!currentParent) {\n        return null;\n      }\n\n      // Next we'll drill down this component to find the first HostComponent/Text.\n      var node = currentParent;\n      while (true) {\n        if (node.tag === HostComponent || node.tag === HostText) {\n          return node;\n        } else if (node.child) {\n          node.child['return'] = node;\n          node = node.child;\n          continue;\n        }\n        if (node === currentParent) {\n          return null;\n        }\n        while (!node.sibling) {\n          if (!node['return'] || node['return'] === currentParent) {\n            return null;\n          }\n          node = node['return'];\n        }\n        node.sibling['return'] = node['return'];\n        node = node.sibling;\n      }\n      // Flow needs the return null here, but ESLint complains about it.\n      // eslint-disable-next-line no-unreachable\n      return null;\n    }\n\n    function findCurrentHostFiberWithNoPortals(parent) {\n      var currentParent = findCurrentFiberUsingSlowPath(parent);\n      if (!currentParent) {\n        return null;\n      }\n\n      // Next we'll drill down this component to find the first HostComponent/Text.\n      var node = currentParent;\n      while (true) {\n        if (node.tag === HostComponent || node.tag === HostText) {\n          return node;\n        } else if (node.child && node.tag !== HostPortal) {\n          node.child['return'] = node;\n          node = node.child;\n          continue;\n        }\n        if (node === currentParent) {\n          return null;\n        }\n        while (!node.sibling) {\n          if (!node['return'] || node['return'] === currentParent) {\n            return null;\n          }\n          node = node['return'];\n        }\n        node.sibling['return'] = node['return'];\n        node = node.sibling;\n      }\n      // Flow needs the return null here, but ESLint complains about it.\n      // eslint-disable-next-line no-unreachable\n      return null;\n    }\n\n    var CALLBACK_BOOKKEEPING_POOL_SIZE = 10;\n    var callbackBookkeepingPool = [];\n\n    /**\n     * Find the deepest React component completely containing the root of the\n     * passed-in instance (for use when entire React trees are nested within each\n     * other). If React trees are not nested, returns null.\n     */\n    function findRootContainerNode(inst) {\n      // TODO: It may be a good idea to cache this to prevent unnecessary DOM\n      // traversal, but caching is difficult to do correctly without using a\n      // mutation observer to listen for all DOM changes.\n      while (inst['return']) {\n        inst = inst['return'];\n      }\n      if (inst.tag !== HostRoot) {\n        // This can happen if we're in a detached tree.\n        return null;\n      }\n      return inst.stateNode.containerInfo;\n    }\n\n    // Used to store ancestor hierarchy in top level callback\n    function getTopLevelCallbackBookKeeping(topLevelType, nativeEvent, targetInst) {\n      if (callbackBookkeepingPool.length) {\n        var instance = callbackBookkeepingPool.pop();\n        instance.topLevelType = topLevelType;\n        instance.nativeEvent = nativeEvent;\n        instance.targetInst = targetInst;\n        return instance;\n      }\n      return {\n        topLevelType: topLevelType,\n        nativeEvent: nativeEvent,\n        targetInst: targetInst,\n        ancestors: []\n      };\n    }\n\n    function releaseTopLevelCallbackBookKeeping(instance) {\n      instance.topLevelType = null;\n      instance.nativeEvent = null;\n      instance.targetInst = null;\n      instance.ancestors.length = 0;\n      if (callbackBookkeepingPool.length < CALLBACK_BOOKKEEPING_POOL_SIZE) {\n        callbackBookkeepingPool.push(instance);\n      }\n    }\n\n    function handleTopLevelImpl(bookKeeping) {\n      var targetInst = bookKeeping.targetInst;\n\n      // Loop through the hierarchy, in case there's any nested components.\n      // It's important that we build the array of ancestors before calling any\n      // event handlers, because event handlers can modify the DOM, leading to\n      // inconsistencies with ReactMount's node cache. See #1105.\n      var ancestor = targetInst;\n      do {\n        if (!ancestor) {\n          bookKeeping.ancestors.push(ancestor);\n          break;\n        }\n        var root = findRootContainerNode(ancestor);\n        if (!root) {\n          break;\n        }\n        bookKeeping.ancestors.push(ancestor);\n        ancestor = getClosestInstanceFromNode(root);\n      } while (ancestor);\n\n      for (var i = 0; i < bookKeeping.ancestors.length; i++) {\n        targetInst = bookKeeping.ancestors[i];\n        _handleTopLevel(bookKeeping.topLevelType, targetInst, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent));\n      }\n    }\n\n    // TODO: can we stop exporting these?\n    var _enabled = true;\n    var _handleTopLevel = void 0;\n\n    function setHandleTopLevel(handleTopLevel) {\n      _handleTopLevel = handleTopLevel;\n    }\n\n    function setEnabled(enabled) {\n      _enabled = !!enabled;\n    }\n\n    function isEnabled() {\n      return _enabled;\n    }\n\n    /**\n     * Traps top-level events by using event bubbling.\n     *\n     * @param {string} topLevelType Record from `BrowserEventConstants`.\n     * @param {string} handlerBaseName Event name (e.g. \"click\").\n     * @param {object} element Element on which to attach listener.\n     * @return {?object} An object with a remove function which will forcefully\n     *                  remove the listener.\n     * @internal\n     */\n    function trapBubbledEvent(topLevelType, handlerBaseName, element) {\n      if (!element) {\n        return null;\n      }\n      return EventListener.listen(element, handlerBaseName, dispatchEvent.bind(null, topLevelType));\n    }\n\n    /**\n     * Traps a top-level event by using event capturing.\n     *\n     * @param {string} topLevelType Record from `BrowserEventConstants`.\n     * @param {string} handlerBaseName Event name (e.g. \"click\").\n     * @param {object} element Element on which to attach listener.\n     * @return {?object} An object with a remove function which will forcefully\n     *                  remove the listener.\n     * @internal\n     */\n    function trapCapturedEvent(topLevelType, handlerBaseName, element) {\n      if (!element) {\n        return null;\n      }\n      return EventListener.capture(element, handlerBaseName, dispatchEvent.bind(null, topLevelType));\n    }\n\n    function dispatchEvent(topLevelType, nativeEvent) {\n      if (!_enabled) {\n        return;\n      }\n\n      var nativeEventTarget = getEventTarget(nativeEvent);\n      var targetInst = getClosestInstanceFromNode(nativeEventTarget);\n      if (targetInst !== null && typeof targetInst.tag === 'number' && !isFiberMounted(targetInst)) {\n        // If we get an event (ex: img onload) before committing that\n        // component's mount, ignore it for now (that is, treat it as if it was an\n        // event on a non-React tree). We might also consider queueing events and\n        // dispatching them after the mount.\n        targetInst = null;\n      }\n\n      var bookKeeping = getTopLevelCallbackBookKeeping(topLevelType, nativeEvent, targetInst);\n\n      try {\n        // Event queue being processed in the same cycle allows\n        // `preventDefault`.\n        batchedUpdates(handleTopLevelImpl, bookKeeping);\n      } finally {\n        releaseTopLevelCallbackBookKeeping(bookKeeping);\n      }\n    }\n\n    var ReactDOMEventListener = Object.freeze({\n      get _enabled() {\n        return _enabled;\n      },\n      get _handleTopLevel() {\n        return _handleTopLevel;\n      },\n      setHandleTopLevel: setHandleTopLevel,\n      setEnabled: setEnabled,\n      isEnabled: isEnabled,\n      trapBubbledEvent: trapBubbledEvent,\n      trapCapturedEvent: trapCapturedEvent,\n      dispatchEvent: dispatchEvent\n    });\n\n    /**\n     * Generate a mapping of standard vendor prefixes using the defined style property and event name.\n     *\n     * @param {string} styleProp\n     * @param {string} eventName\n     * @returns {object}\n     */\n    function makePrefixMap(styleProp, eventName) {\n      var prefixes = {};\n\n      prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();\n      prefixes['Webkit' + styleProp] = 'webkit' + eventName;\n      prefixes['Moz' + styleProp] = 'moz' + eventName;\n      prefixes['ms' + styleProp] = 'MS' + eventName;\n      prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();\n\n      return prefixes;\n    }\n\n    /**\n     * A list of event names to a configurable list of vendor prefixes.\n     */\n    var vendorPrefixes = {\n      animationend: makePrefixMap('Animation', 'AnimationEnd'),\n      animationiteration: makePrefixMap('Animation', 'AnimationIteration'),\n      animationstart: makePrefixMap('Animation', 'AnimationStart'),\n      transitionend: makePrefixMap('Transition', 'TransitionEnd')\n    };\n\n    /**\n     * Event names that have already been detected and prefixed (if applicable).\n     */\n    var prefixedEventNames = {};\n\n    /**\n     * Element to check for prefixes on.\n     */\n    var style = {};\n\n    /**\n     * Bootstrap if a DOM exists.\n     */\n    if (ExecutionEnvironment.canUseDOM) {\n      style = document.createElement('div').style;\n\n      // On some platforms, in particular some releases of Android 4.x,\n      // the un-prefixed \"animation\" and \"transition\" properties are defined on the\n      // style object but the events that fire will still be prefixed, so we need\n      // to check if the un-prefixed events are usable, and if not remove them from the map.\n      if (!('AnimationEvent' in window)) {\n        delete vendorPrefixes.animationend.animation;\n        delete vendorPrefixes.animationiteration.animation;\n        delete vendorPrefixes.animationstart.animation;\n      }\n\n      // Same as above\n      if (!('TransitionEvent' in window)) {\n        delete vendorPrefixes.transitionend.transition;\n      }\n    }\n\n    /**\n     * Attempts to determine the correct vendor prefixed event name.\n     *\n     * @param {string} eventName\n     * @returns {string}\n     */\n    function getVendorPrefixedEventName(eventName) {\n      if (prefixedEventNames[eventName]) {\n        return prefixedEventNames[eventName];\n      } else if (!vendorPrefixes[eventName]) {\n        return eventName;\n      }\n\n      var prefixMap = vendorPrefixes[eventName];\n\n      for (var styleProp in prefixMap) {\n        if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {\n          return prefixedEventNames[eventName] = prefixMap[styleProp];\n        }\n      }\n\n      return '';\n    }\n\n    /**\n     * Types of raw signals from the browser caught at the top level.\n     *\n     * For events like 'submit' which don't consistently bubble (which we\n     * trap at a lower node than `document`), binding at `document` would\n     * cause duplicate events so we don't include them here.\n     */\n    var topLevelTypes$1 = {\n      topAbort: 'abort',\n      topAnimationEnd: getVendorPrefixedEventName('animationend') || 'animationend',\n      topAnimationIteration: getVendorPrefixedEventName('animationiteration') || 'animationiteration',\n      topAnimationStart: getVendorPrefixedEventName('animationstart') || 'animationstart',\n      topBlur: 'blur',\n      topCancel: 'cancel',\n      topCanPlay: 'canplay',\n      topCanPlayThrough: 'canplaythrough',\n      topChange: 'change',\n      topClick: 'click',\n      topClose: 'close',\n      topCompositionEnd: 'compositionend',\n      topCompositionStart: 'compositionstart',\n      topCompositionUpdate: 'compositionupdate',\n      topContextMenu: 'contextmenu',\n      topCopy: 'copy',\n      topCut: 'cut',\n      topDoubleClick: 'dblclick',\n      topDrag: 'drag',\n      topDragEnd: 'dragend',\n      topDragEnter: 'dragenter',\n      topDragExit: 'dragexit',\n      topDragLeave: 'dragleave',\n      topDragOver: 'dragover',\n      topDragStart: 'dragstart',\n      topDrop: 'drop',\n      topDurationChange: 'durationchange',\n      topEmptied: 'emptied',\n      topEncrypted: 'encrypted',\n      topEnded: 'ended',\n      topError: 'error',\n      topFocus: 'focus',\n      topInput: 'input',\n      topKeyDown: 'keydown',\n      topKeyPress: 'keypress',\n      topKeyUp: 'keyup',\n      topLoadedData: 'loadeddata',\n      topLoad: 'load',\n      topLoadedMetadata: 'loadedmetadata',\n      topLoadStart: 'loadstart',\n      topMouseDown: 'mousedown',\n      topMouseMove: 'mousemove',\n      topMouseOut: 'mouseout',\n      topMouseOver: 'mouseover',\n      topMouseUp: 'mouseup',\n      topPaste: 'paste',\n      topPause: 'pause',\n      topPlay: 'play',\n      topPlaying: 'playing',\n      topProgress: 'progress',\n      topRateChange: 'ratechange',\n      topScroll: 'scroll',\n      topSeeked: 'seeked',\n      topSeeking: 'seeking',\n      topSelectionChange: 'selectionchange',\n      topStalled: 'stalled',\n      topSuspend: 'suspend',\n      topTextInput: 'textInput',\n      topTimeUpdate: 'timeupdate',\n      topToggle: 'toggle',\n      topTouchCancel: 'touchcancel',\n      topTouchEnd: 'touchend',\n      topTouchMove: 'touchmove',\n      topTouchStart: 'touchstart',\n      topTransitionEnd: getVendorPrefixedEventName('transitionend') || 'transitionend',\n      topVolumeChange: 'volumechange',\n      topWaiting: 'waiting',\n      topWheel: 'wheel'\n    };\n\n    var BrowserEventConstants = {\n      topLevelTypes: topLevelTypes$1\n    };\n\n    function runEventQueueInBatch(events) {\n      enqueueEvents(events);\n      processEventQueue(false);\n    }\n\n    /**\n     * Streams a fired top-level event to `EventPluginHub` where plugins have the\n     * opportunity to create `ReactEvent`s to be dispatched.\n     */\n    function handleTopLevel(topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n      var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);\n      runEventQueueInBatch(events);\n    }\n\n    var topLevelTypes = BrowserEventConstants.topLevelTypes;\n\n    /**\n     * Summary of `ReactBrowserEventEmitter` event handling:\n     *\n     *  - Top-level delegation is used to trap most native browser events. This\n     *    may only occur in the main thread and is the responsibility of\n     *    ReactDOMEventListener, which is injected and can therefore support\n     *    pluggable event sources. This is the only work that occurs in the main\n     *    thread.\n     *\n     *  - We normalize and de-duplicate events to account for browser quirks. This\n     *    may be done in the worker thread.\n     *\n     *  - Forward these native events (with the associated top-level type used to\n     *    trap it) to `EventPluginHub`, which in turn will ask plugins if they want\n     *    to extract any synthetic events.\n     *\n     *  - The `EventPluginHub` will then process each event by annotating them with\n     *    \"dispatches\", a sequence of listeners and IDs that care about that event.\n     *\n     *  - The `EventPluginHub` then dispatches the events.\n     *\n     * Overview of React and the event system:\n     *\n     * +------------+    .\n     * |    DOM     |    .\n     * +------------+    .\n     *       |           .\n     *       v           .\n     * +------------+    .\n     * | ReactEvent |    .\n     * |  Listener  |    .\n     * +------------+    .                         +-----------+\n     *       |           .               +--------+|SimpleEvent|\n     *       |           .               |         |Plugin     |\n     * +-----|------+    .               v         +-----------+\n     * |     |      |    .    +--------------+                    +------------+\n     * |     +-----------.--->|EventPluginHub|                    |    Event   |\n     * |            |    .    |              |     +-----------+  | Propagators|\n     * | ReactEvent |    .    |              |     |TapEvent   |  |------------|\n     * |  Emitter   |    .    |              |<---+|Plugin     |  |other plugin|\n     * |            |    .    |              |     +-----------+  |  utilities |\n     * |     +-----------.--->|              |                    +------------+\n     * |     |      |    .    +--------------+\n     * +-----|------+    .                ^        +-----------+\n     *       |           .                |        |Enter/Leave|\n     *       +           .                +-------+|Plugin     |\n     * +-------------+   .                         +-----------+\n     * | application |   .\n     * |-------------|   .\n     * |             |   .\n     * |             |   .\n     * +-------------+   .\n     *                   .\n     *    React Core     .  General Purpose Event Plugin System\n     */\n\n    var alreadyListeningTo = {};\n    var reactTopListenersCounter = 0;\n\n    /**\n     * To ensure no conflicts with other potential React instances on the page\n     */\n    var topListenersIDKey = '_reactListenersID' + ('' + Math.random()).slice(2);\n\n    function getListeningForDocument(mountAt) {\n      // In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`\n      // directly.\n      if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {\n        mountAt[topListenersIDKey] = reactTopListenersCounter++;\n        alreadyListeningTo[mountAt[topListenersIDKey]] = {};\n      }\n      return alreadyListeningTo[mountAt[topListenersIDKey]];\n    }\n\n    /**\n     * We listen for bubbled touch events on the document object.\n     *\n     * Firefox v8.01 (and possibly others) exhibited strange behavior when\n     * mounting `onmousemove` events at some node that was not the document\n     * element. The symptoms were that if your mouse is not moving over something\n     * contained within that mount point (for example on the background) the\n     * top-level listeners for `onmousemove` won't be called. However, if you\n     * register the `mousemove` on the document object, then it will of course\n     * catch all `mousemove`s. This along with iOS quirks, justifies restricting\n     * top-level listeners to the document object only, at least for these\n     * movement types of events and possibly all events.\n     *\n     * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html\n     *\n     * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but\n     * they bubble to document.\n     *\n     * @param {string} registrationName Name of listener (e.g. `onClick`).\n     * @param {object} contentDocumentHandle Document which owns the container\n     */\n    function listenTo(registrationName, contentDocumentHandle) {\n      var mountAt = contentDocumentHandle;\n      var isListening = getListeningForDocument(mountAt);\n      var dependencies = registrationNameDependencies[registrationName];\n\n      for (var i = 0; i < dependencies.length; i++) {\n        var dependency = dependencies[i];\n        if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {\n          if (dependency === 'topScroll') {\n            trapCapturedEvent('topScroll', 'scroll', mountAt);\n          } else if (dependency === 'topFocus' || dependency === 'topBlur') {\n            trapCapturedEvent('topFocus', 'focus', mountAt);\n            trapCapturedEvent('topBlur', 'blur', mountAt);\n\n            // to make sure blur and focus event listeners are only attached once\n            isListening.topBlur = true;\n            isListening.topFocus = true;\n          } else if (dependency === 'topCancel') {\n            if (isEventSupported('cancel', true)) {\n              trapCapturedEvent('topCancel', 'cancel', mountAt);\n            }\n            isListening.topCancel = true;\n          } else if (dependency === 'topClose') {\n            if (isEventSupported('close', true)) {\n              trapCapturedEvent('topClose', 'close', mountAt);\n            }\n            isListening.topClose = true;\n          } else if (topLevelTypes.hasOwnProperty(dependency)) {\n            trapBubbledEvent(dependency, topLevelTypes[dependency], mountAt);\n          }\n\n          isListening[dependency] = true;\n        }\n      }\n    }\n\n    function isListeningToAllDependencies(registrationName, mountAt) {\n      var isListening = getListeningForDocument(mountAt);\n      var dependencies = registrationNameDependencies[registrationName];\n      for (var i = 0; i < dependencies.length; i++) {\n        var dependency = dependencies[i];\n        if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) {\n          return false;\n        }\n      }\n      return true;\n    }\n\n    /**\n     * Given any node return the first leaf node without children.\n     *\n     * @param {DOMElement|DOMTextNode} node\n     * @return {DOMElement|DOMTextNode}\n     */\n    function getLeafNode(node) {\n      while (node && node.firstChild) {\n        node = node.firstChild;\n      }\n      return node;\n    }\n\n    /**\n     * Get the next sibling within a container. This will walk up the\n     * DOM if a node's siblings have been exhausted.\n     *\n     * @param {DOMElement|DOMTextNode} node\n     * @return {?DOMElement|DOMTextNode}\n     */\n    function getSiblingNode(node) {\n      while (node) {\n        if (node.nextSibling) {\n          return node.nextSibling;\n        }\n        node = node.parentNode;\n      }\n    }\n\n    /**\n     * Get object describing the nodes which contain characters at offset.\n     *\n     * @param {DOMElement|DOMTextNode} root\n     * @param {number} offset\n     * @return {?object}\n     */\n    function getNodeForCharacterOffset(root, offset) {\n      var node = getLeafNode(root);\n      var nodeStart = 0;\n      var nodeEnd = 0;\n\n      while (node) {\n        if (node.nodeType === TEXT_NODE) {\n          nodeEnd = nodeStart + node.textContent.length;\n\n          if (nodeStart <= offset && nodeEnd >= offset) {\n            return {\n              node: node,\n              offset: offset - nodeStart\n            };\n          }\n\n          nodeStart = nodeEnd;\n        }\n\n        node = getLeafNode(getSiblingNode(node));\n      }\n    }\n\n    /**\n     * @param {DOMElement} outerNode\n     * @return {?object}\n     */\n    function getOffsets(outerNode) {\n      var selection = window.getSelection && window.getSelection();\n\n      if (!selection || selection.rangeCount === 0) {\n        return null;\n      }\n\n      var anchorNode = selection.anchorNode,\n          anchorOffset = selection.anchorOffset,\n          focusNode$$1 = selection.focusNode,\n          focusOffset = selection.focusOffset;\n\n      // In Firefox, anchorNode and focusNode can be \"anonymous divs\", e.g. the\n      // up/down buttons on an <input type=\"number\">. Anonymous divs do not seem to\n      // expose properties, triggering a \"Permission denied error\" if any of its\n      // properties are accessed. The only seemingly possible way to avoid erroring\n      // is to access a property that typically works for non-anonymous divs and\n      // catch any error that may otherwise arise. See\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=208427\n\n      try {\n        /* eslint-disable no-unused-expressions */\n        anchorNode.nodeType;\n        focusNode$$1.nodeType;\n        /* eslint-enable no-unused-expressions */\n      } catch (e) {\n        return null;\n      }\n\n      return getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode$$1, focusOffset);\n    }\n\n    /**\n     * Returns {start, end} where `start` is the character/codepoint index of\n     * (anchorNode, anchorOffset) within the textContent of `outerNode`, and\n     * `end` is the index of (focusNode, focusOffset).\n     *\n     * Returns null if you pass in garbage input but we should probably just crash.\n     *\n     * Exported only for testing.\n     */\n    function getModernOffsetsFromPoints(outerNode, anchorNode, anchorOffset, focusNode$$1, focusOffset) {\n      var length = 0;\n      var start = -1;\n      var end = -1;\n      var indexWithinAnchor = 0;\n      var indexWithinFocus = 0;\n      var node = outerNode;\n      var parentNode = null;\n\n      outer: while (true) {\n        var next = null;\n\n        while (true) {\n          if (node === anchorNode && (anchorOffset === 0 || node.nodeType === TEXT_NODE)) {\n            start = length + anchorOffset;\n          }\n          if (node === focusNode$$1 && (focusOffset === 0 || node.nodeType === TEXT_NODE)) {\n            end = length + focusOffset;\n          }\n\n          if (node.nodeType === TEXT_NODE) {\n            length += node.nodeValue.length;\n          }\n\n          if ((next = node.firstChild) === null) {\n            break;\n          }\n          // Moving from `node` to its first child `next`.\n          parentNode = node;\n          node = next;\n        }\n\n        while (true) {\n          if (node === outerNode) {\n            // If `outerNode` has children, this is always the second time visiting\n            // it. If it has no children, this is still the first loop, and the only\n            // valid selection is anchorNode and focusNode both equal to this node\n            // and both offsets 0, in which case we will have handled above.\n            break outer;\n          }\n          if (parentNode === anchorNode && ++indexWithinAnchor === anchorOffset) {\n            start = length;\n          }\n          if (parentNode === focusNode$$1 && ++indexWithinFocus === focusOffset) {\n            end = length;\n          }\n          if ((next = node.nextSibling) !== null) {\n            break;\n          }\n          node = parentNode;\n          parentNode = node.parentNode;\n        }\n\n        // Moving from `node` to its next sibling `next`.\n        node = next;\n      }\n\n      if (start === -1 || end === -1) {\n        // This should never happen. (Would happen if the anchor/focus nodes aren't\n        // actually inside the passed-in node.)\n        return null;\n      }\n\n      return {\n        start: start,\n        end: end\n      };\n    }\n\n    /**\n     * In modern non-IE browsers, we can support both forward and backward\n     * selections.\n     *\n     * Note: IE10+ supports the Selection object, but it does not support\n     * the `extend` method, which means that even in modern IE, it's not possible\n     * to programmatically create a backward selection. Thus, for all IE\n     * versions, we use the old IE API to create our selections.\n     *\n     * @param {DOMElement|DOMTextNode} node\n     * @param {object} offsets\n     */\n    function setOffsets(node, offsets) {\n      if (!window.getSelection) {\n        return;\n      }\n\n      var selection = window.getSelection();\n      var length = node[getTextContentAccessor()].length;\n      var start = Math.min(offsets.start, length);\n      var end = offsets.end === undefined ? start : Math.min(offsets.end, length);\n\n      // IE 11 uses modern selection, but doesn't support the extend method.\n      // Flip backward selections, so we can set with a single range.\n      if (!selection.extend && start > end) {\n        var temp = end;\n        end = start;\n        start = temp;\n      }\n\n      var startMarker = getNodeForCharacterOffset(node, start);\n      var endMarker = getNodeForCharacterOffset(node, end);\n\n      if (startMarker && endMarker) {\n        if (selection.rangeCount === 1 && selection.anchorNode === startMarker.node && selection.anchorOffset === startMarker.offset && selection.focusNode === endMarker.node && selection.focusOffset === endMarker.offset) {\n          return;\n        }\n        var range = document.createRange();\n        range.setStart(startMarker.node, startMarker.offset);\n        selection.removeAllRanges();\n\n        if (start > end) {\n          selection.addRange(range);\n          selection.extend(endMarker.node, endMarker.offset);\n        } else {\n          range.setEnd(endMarker.node, endMarker.offset);\n          selection.addRange(range);\n        }\n      }\n    }\n\n    function isInDocument(node) {\n      return containsNode(document.documentElement, node);\n    }\n\n    /**\n     * @ReactInputSelection: React input selection module. Based on Selection.js,\n     * but modified to be suitable for react and has a couple of bug fixes (doesn't\n     * assume buttons have range selections allowed).\n     * Input selection module for React.\n     */\n\n    function hasSelectionCapabilities(elem) {\n      var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();\n      return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true');\n    }\n\n    function getSelectionInformation() {\n      var focusedElem = getActiveElement();\n      return {\n        focusedElem: focusedElem,\n        selectionRange: hasSelectionCapabilities(focusedElem) ? getSelection$1(focusedElem) : null\n      };\n    }\n\n    /**\n     * @restoreSelection: If any selection information was potentially lost,\n     * restore it. This is useful when performing operations that could remove dom\n     * nodes and place them back in, resulting in focus being lost.\n     */\n    function restoreSelection(priorSelectionInformation) {\n      var curFocusedElem = getActiveElement();\n      var priorFocusedElem = priorSelectionInformation.focusedElem;\n      var priorSelectionRange = priorSelectionInformation.selectionRange;\n      if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) {\n        if (hasSelectionCapabilities(priorFocusedElem)) {\n          setSelection(priorFocusedElem, priorSelectionRange);\n        }\n\n        // Focusing a node can change the scroll position, which is undesirable\n        var ancestors = [];\n        var ancestor = priorFocusedElem;\n        while (ancestor = ancestor.parentNode) {\n          if (ancestor.nodeType === ELEMENT_NODE) {\n            ancestors.push({\n              element: ancestor,\n              left: ancestor.scrollLeft,\n              top: ancestor.scrollTop\n            });\n          }\n        }\n\n        focusNode(priorFocusedElem);\n\n        for (var i = 0; i < ancestors.length; i++) {\n          var info = ancestors[i];\n          info.element.scrollLeft = info.left;\n          info.element.scrollTop = info.top;\n        }\n      }\n    }\n\n    /**\n     * @getSelection: Gets the selection bounds of a focused textarea, input or\n     * contentEditable node.\n     * -@input: Look up selection bounds of this input\n     * -@return {start: selectionStart, end: selectionEnd}\n     */\n    function getSelection$1(input) {\n      var selection = void 0;\n\n      if ('selectionStart' in input) {\n        // Modern browser with input or textarea.\n        selection = {\n          start: input.selectionStart,\n          end: input.selectionEnd\n        };\n      } else {\n        // Content editable or old IE textarea.\n        selection = getOffsets(input);\n      }\n\n      return selection || { start: 0, end: 0 };\n    }\n\n    /**\n     * @setSelection: Sets the selection bounds of a textarea or input and focuses\n     * the input.\n     * -@input     Set selection bounds of this input or textarea\n     * -@offsets   Object of same form that is returned from get*\n     */\n    function setSelection(input, offsets) {\n      var start = offsets.start,\n          end = offsets.end;\n\n      if (end === undefined) {\n        end = start;\n      }\n\n      if ('selectionStart' in input) {\n        input.selectionStart = start;\n        input.selectionEnd = Math.min(end, input.value.length);\n      } else {\n        setOffsets(input, offsets);\n      }\n    }\n\n    var skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11;\n\n    var eventTypes$3 = {\n      select: {\n        phasedRegistrationNames: {\n          bubbled: 'onSelect',\n          captured: 'onSelectCapture'\n        },\n        dependencies: ['topBlur', 'topContextMenu', 'topFocus', 'topKeyDown', 'topKeyUp', 'topMouseDown', 'topMouseUp', 'topSelectionChange']\n      }\n    };\n\n    var activeElement$1 = null;\n    var activeElementInst$1 = null;\n    var lastSelection = null;\n    var mouseDown = false;\n\n    /**\n     * Get an object which is a unique representation of the current selection.\n     *\n     * The return value will not be consistent across nodes or browsers, but\n     * two identical selections on the same node will return identical objects.\n     *\n     * @param {DOMElement} node\n     * @return {object}\n     */\n    function getSelection(node) {\n      if ('selectionStart' in node && hasSelectionCapabilities(node)) {\n        return {\n          start: node.selectionStart,\n          end: node.selectionEnd\n        };\n      } else if (window.getSelection) {\n        var selection = window.getSelection();\n        return {\n          anchorNode: selection.anchorNode,\n          anchorOffset: selection.anchorOffset,\n          focusNode: selection.focusNode,\n          focusOffset: selection.focusOffset\n        };\n      }\n    }\n\n    /**\n     * Poll selection to see whether it's changed.\n     *\n     * @param {object} nativeEvent\n     * @return {?SyntheticEvent}\n     */\n    function constructSelectEvent(nativeEvent, nativeEventTarget) {\n      // Ensure we have the right element, and that the user is not dragging a\n      // selection (this matches native `select` event behavior). In HTML5, select\n      // fires only on input and textarea thus if there's no focused element we\n      // won't dispatch.\n      if (mouseDown || activeElement$1 == null || activeElement$1 !== getActiveElement()) {\n        return null;\n      }\n\n      // Only fire when selection has actually changed.\n      var currentSelection = getSelection(activeElement$1);\n      if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) {\n        lastSelection = currentSelection;\n\n        var syntheticEvent = SyntheticEvent$1.getPooled(eventTypes$3.select, activeElementInst$1, nativeEvent, nativeEventTarget);\n\n        syntheticEvent.type = 'select';\n        syntheticEvent.target = activeElement$1;\n\n        accumulateTwoPhaseDispatches(syntheticEvent);\n\n        return syntheticEvent;\n      }\n\n      return null;\n    }\n\n    /**\n     * This plugin creates an `onSelect` event that normalizes select events\n     * across form elements.\n     *\n     * Supported elements are:\n     * - input (see `isTextInputElement`)\n     * - textarea\n     * - contentEditable\n     *\n     * This differs from native browser implementations in the following ways:\n     * - Fires on contentEditable fields as well as inputs.\n     * - Fires for collapsed selection.\n     * - Fires after user input.\n     */\n    var SelectEventPlugin = {\n      eventTypes: eventTypes$3,\n\n      extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n        var doc = nativeEventTarget.window === nativeEventTarget ? nativeEventTarget.document : nativeEventTarget.nodeType === DOCUMENT_NODE ? nativeEventTarget : nativeEventTarget.ownerDocument;\n        // Track whether all listeners exists for this plugin. If none exist, we do\n        // not extract events. See #3639.\n        if (!doc || !isListeningToAllDependencies('onSelect', doc)) {\n          return null;\n        }\n\n        var targetNode = targetInst ? getNodeFromInstance$1(targetInst) : window;\n\n        switch (topLevelType) {\n          // Track the input node that has focus.\n          case 'topFocus':\n            if (isTextInputElement(targetNode) || targetNode.contentEditable === 'true') {\n              activeElement$1 = targetNode;\n              activeElementInst$1 = targetInst;\n              lastSelection = null;\n            }\n            break;\n          case 'topBlur':\n            activeElement$1 = null;\n            activeElementInst$1 = null;\n            lastSelection = null;\n            break;\n          // Don't fire the event while the user is dragging. This matches the\n          // semantics of the native select event.\n          case 'topMouseDown':\n            mouseDown = true;\n            break;\n          case 'topContextMenu':\n          case 'topMouseUp':\n            mouseDown = false;\n            return constructSelectEvent(nativeEvent, nativeEventTarget);\n          // Chrome and IE fire non-standard event when selection is changed (and\n          // sometimes when it hasn't). IE's event fires out of order with respect\n          // to key and input events on deletion, so we discard it.\n          //\n          // Firefox doesn't support selectionchange, so check selection status\n          // after each key entry. The selection changes after keydown and before\n          // keyup, but we check on keydown as well in the case of holding down a\n          // key, when multiple keydown events are fired but only one keyup is.\n          // This is also our approach for IE handling, for the reason above.\n          case 'topSelectionChange':\n            if (skipSelectionChangeEvent) {\n              break;\n            }\n          // falls through\n          case 'topKeyDown':\n          case 'topKeyUp':\n            return constructSelectEvent(nativeEvent, nativeEventTarget);\n        }\n\n        return null;\n      }\n    };\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/css3-animations/#AnimationEvent-interface\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/AnimationEvent\n     */\n    var AnimationEventInterface = {\n      animationName: null,\n      elapsedTime: null,\n      pseudoElement: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticAnimationEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticAnimationEvent, AnimationEventInterface);\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/clipboard-apis/\n     */\n    var ClipboardEventInterface = {\n      clipboardData: function (event) {\n        return 'clipboardData' in event ? event.clipboardData : window.clipboardData;\n      }\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface);\n\n    /**\n     * @interface FocusEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var FocusEventInterface = {\n      relatedTarget: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticUIEvent}\n     */\n    function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface);\n\n    /**\n     * `charCode` represents the actual \"character code\" and is safe to use with\n     * `String.fromCharCode`. As such, only keys that correspond to printable\n     * characters produce a valid `charCode`, the only exception to this is Enter.\n     * The Tab-key is considered non-printable and does not have a `charCode`,\n     * presumably because it does not produce a tab-character in browsers.\n     *\n     * @param {object} nativeEvent Native browser event.\n     * @return {number} Normalized `charCode` property.\n     */\n    function getEventCharCode(nativeEvent) {\n      var charCode;\n      var keyCode = nativeEvent.keyCode;\n\n      if ('charCode' in nativeEvent) {\n        charCode = nativeEvent.charCode;\n\n        // FF does not set `charCode` for the Enter-key, check against `keyCode`.\n        if (charCode === 0 && keyCode === 13) {\n          charCode = 13;\n        }\n      } else {\n        // IE8 does not implement `charCode`, but `keyCode` has the correct value.\n        charCode = keyCode;\n      }\n\n      // Some non-printable keys are reported in `charCode`/`keyCode`, discard them.\n      // Must not discard the (non-)printable Enter-key.\n      if (charCode >= 32 || charCode === 13) {\n        return charCode;\n      }\n\n      return 0;\n    }\n\n    /**\n     * Normalization of deprecated HTML5 `key` values\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n     */\n    var normalizeKey = {\n      Esc: 'Escape',\n      Spacebar: ' ',\n      Left: 'ArrowLeft',\n      Up: 'ArrowUp',\n      Right: 'ArrowRight',\n      Down: 'ArrowDown',\n      Del: 'Delete',\n      Win: 'OS',\n      Menu: 'ContextMenu',\n      Apps: 'ContextMenu',\n      Scroll: 'ScrollLock',\n      MozPrintableKey: 'Unidentified'\n    };\n\n    /**\n     * Translation from legacy `keyCode` to HTML5 `key`\n     * Only special keys supported, all others depend on keyboard layout or browser\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names\n     */\n    var translateToKey = {\n      '8': 'Backspace',\n      '9': 'Tab',\n      '12': 'Clear',\n      '13': 'Enter',\n      '16': 'Shift',\n      '17': 'Control',\n      '18': 'Alt',\n      '19': 'Pause',\n      '20': 'CapsLock',\n      '27': 'Escape',\n      '32': ' ',\n      '33': 'PageUp',\n      '34': 'PageDown',\n      '35': 'End',\n      '36': 'Home',\n      '37': 'ArrowLeft',\n      '38': 'ArrowUp',\n      '39': 'ArrowRight',\n      '40': 'ArrowDown',\n      '45': 'Insert',\n      '46': 'Delete',\n      '112': 'F1',\n      '113': 'F2',\n      '114': 'F3',\n      '115': 'F4',\n      '116': 'F5',\n      '117': 'F6',\n      '118': 'F7',\n      '119': 'F8',\n      '120': 'F9',\n      '121': 'F10',\n      '122': 'F11',\n      '123': 'F12',\n      '144': 'NumLock',\n      '145': 'ScrollLock',\n      '224': 'Meta'\n    };\n\n    /**\n     * @param {object} nativeEvent Native browser event.\n     * @return {string} Normalized `key` property.\n     */\n    function getEventKey(nativeEvent) {\n      if (nativeEvent.key) {\n        // Normalize inconsistent values reported by browsers due to\n        // implementations of a working draft specification.\n\n        // FireFox implements `key` but returns `MozPrintableKey` for all\n        // printable characters (normalized to `Unidentified`), ignore it.\n        var key = normalizeKey[nativeEvent.key] || nativeEvent.key;\n        if (key !== 'Unidentified') {\n          return key;\n        }\n      }\n\n      // Browser does not implement `key`, polyfill as much of it as we can.\n      if (nativeEvent.type === 'keypress') {\n        var charCode = getEventCharCode(nativeEvent);\n\n        // The enter-key is technically both printable and non-printable and can\n        // thus be captured by `keypress`, no other non-printable key should.\n        return charCode === 13 ? 'Enter' : String.fromCharCode(charCode);\n      }\n      if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') {\n        // While user keyboard layout determines the actual meaning of each\n        // `keyCode` value, almost all function keys have a universal value.\n        return translateToKey[nativeEvent.keyCode] || 'Unidentified';\n      }\n      return '';\n    }\n\n    /**\n     * @interface KeyboardEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var KeyboardEventInterface = {\n      key: getEventKey,\n      location: null,\n      ctrlKey: null,\n      shiftKey: null,\n      altKey: null,\n      metaKey: null,\n      repeat: null,\n      locale: null,\n      getModifierState: getEventModifierState,\n      // Legacy Interface\n      charCode: function (event) {\n        // `charCode` is the result of a KeyPress event and represents the value of\n        // the actual printable character.\n\n        // KeyPress is deprecated, but its replacement is not yet final and not\n        // implemented in any major browser. Only KeyPress has charCode.\n        if (event.type === 'keypress') {\n          return getEventCharCode(event);\n        }\n        return 0;\n      },\n      keyCode: function (event) {\n        // `keyCode` is the result of a KeyDown/Up event and represents the value of\n        // physical keyboard key.\n\n        // The actual meaning of the value depends on the users' keyboard layout\n        // which cannot be detected. Assuming that it is a US keyboard layout\n        // provides a surprisingly accurate mapping for US and European users.\n        // Due to this, it is left to the user to implement at this time.\n        if (event.type === 'keydown' || event.type === 'keyup') {\n          return event.keyCode;\n        }\n        return 0;\n      },\n      which: function (event) {\n        // `which` is an alias for either `keyCode` or `charCode` depending on the\n        // type of the event.\n        if (event.type === 'keypress') {\n          return getEventCharCode(event);\n        }\n        if (event.type === 'keydown' || event.type === 'keyup') {\n          return event.keyCode;\n        }\n        return 0;\n      }\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticUIEvent}\n     */\n    function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface);\n\n    /**\n     * @interface DragEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var DragEventInterface = {\n      dataTransfer: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticMouseEvent}\n     */\n    function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface);\n\n    /**\n     * @interface TouchEvent\n     * @see http://www.w3.org/TR/touch-events/\n     */\n    var TouchEventInterface = {\n      touches: null,\n      targetTouches: null,\n      changedTouches: null,\n      altKey: null,\n      metaKey: null,\n      ctrlKey: null,\n      shiftKey: null,\n      getModifierState: getEventModifierState\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticUIEvent}\n     */\n    function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface);\n\n    /**\n     * @interface Event\n     * @see http://www.w3.org/TR/2009/WD-css3-transitions-20090320/#transition-events-\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/TransitionEvent\n     */\n    var TransitionEventInterface = {\n      propertyName: null,\n      elapsedTime: null,\n      pseudoElement: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticEvent}\n     */\n    function SyntheticTransitionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticEvent$1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticEvent$1.augmentClass(SyntheticTransitionEvent, TransitionEventInterface);\n\n    /**\n     * @interface WheelEvent\n     * @see http://www.w3.org/TR/DOM-Level-3-Events/\n     */\n    var WheelEventInterface = {\n      deltaX: function (event) {\n        return 'deltaX' in event ? event.deltaX : // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive).\n        'wheelDeltaX' in event ? -event.wheelDeltaX : 0;\n      },\n      deltaY: function (event) {\n        return 'deltaY' in event ? event.deltaY : // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive).\n        'wheelDeltaY' in event ? -event.wheelDeltaY : // Fallback to `wheelDelta` for IE<9 and normalize (down is positive).\n        'wheelDelta' in event ? -event.wheelDelta : 0;\n      },\n      deltaZ: null,\n\n      // Browsers without \"deltaMode\" is reporting in raw wheel delta where one\n      // notch on the scroll is always +/- 120, roughly equivalent to pixels.\n      // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or\n      // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size.\n      deltaMode: null\n    };\n\n    /**\n     * @param {object} dispatchConfig Configuration used to dispatch this event.\n     * @param {string} dispatchMarker Marker identifying the event target.\n     * @param {object} nativeEvent Native browser event.\n     * @extends {SyntheticMouseEvent}\n     */\n    function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {\n      return SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);\n    }\n\n    SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface);\n\n    /**\n     * Turns\n     * ['abort', ...]\n     * into\n     * eventTypes = {\n     *   'abort': {\n     *     phasedRegistrationNames: {\n     *       bubbled: 'onAbort',\n     *       captured: 'onAbortCapture',\n     *     },\n     *     dependencies: ['topAbort'],\n     *   },\n     *   ...\n     * };\n     * topLevelEventsToDispatchConfig = {\n     *   'topAbort': { sameConfig }\n     * };\n     */\n    var eventTypes$4 = {};\n    var topLevelEventsToDispatchConfig = {};\n    ['abort', 'animationEnd', 'animationIteration', 'animationStart', 'blur', 'cancel', 'canPlay', 'canPlayThrough', 'click', 'close', 'contextMenu', 'copy', 'cut', 'doubleClick', 'drag', 'dragEnd', 'dragEnter', 'dragExit', 'dragLeave', 'dragOver', 'dragStart', 'drop', 'durationChange', 'emptied', 'encrypted', 'ended', 'error', 'focus', 'input', 'invalid', 'keyDown', 'keyPress', 'keyUp', 'load', 'loadedData', 'loadedMetadata', 'loadStart', 'mouseDown', 'mouseMove', 'mouseOut', 'mouseOver', 'mouseUp', 'paste', 'pause', 'play', 'playing', 'progress', 'rateChange', 'reset', 'scroll', 'seeked', 'seeking', 'stalled', 'submit', 'suspend', 'timeUpdate', 'toggle', 'touchCancel', 'touchEnd', 'touchMove', 'touchStart', 'transitionEnd', 'volumeChange', 'waiting', 'wheel'].forEach(function (event) {\n      var capitalizedEvent = event[0].toUpperCase() + event.slice(1);\n      var onEvent = 'on' + capitalizedEvent;\n      var topEvent = 'top' + capitalizedEvent;\n\n      var type = {\n        phasedRegistrationNames: {\n          bubbled: onEvent,\n          captured: onEvent + 'Capture'\n        },\n        dependencies: [topEvent]\n      };\n      eventTypes$4[event] = type;\n      topLevelEventsToDispatchConfig[topEvent] = type;\n    });\n\n    // Only used in DEV for exhaustiveness validation.\n    var knownHTMLTopLevelTypes = ['topAbort', 'topCancel', 'topCanPlay', 'topCanPlayThrough', 'topClose', 'topDurationChange', 'topEmptied', 'topEncrypted', 'topEnded', 'topError', 'topInput', 'topInvalid', 'topLoad', 'topLoadedData', 'topLoadedMetadata', 'topLoadStart', 'topPause', 'topPlay', 'topPlaying', 'topProgress', 'topRateChange', 'topReset', 'topSeeked', 'topSeeking', 'topStalled', 'topSubmit', 'topSuspend', 'topTimeUpdate', 'topToggle', 'topVolumeChange', 'topWaiting'];\n\n    var SimpleEventPlugin = {\n      eventTypes: eventTypes$4,\n\n      extractEvents: function (topLevelType, targetInst, nativeEvent, nativeEventTarget) {\n        var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType];\n        if (!dispatchConfig) {\n          return null;\n        }\n        var EventConstructor;\n        switch (topLevelType) {\n          case 'topKeyPress':\n            // Firefox creates a keypress event for function keys too. This removes\n            // the unwanted keypress events. Enter is however both printable and\n            // non-printable. One would expect Tab to be as well (but it isn't).\n            if (getEventCharCode(nativeEvent) === 0) {\n              return null;\n            }\n          /* falls through */\n          case 'topKeyDown':\n          case 'topKeyUp':\n            EventConstructor = SyntheticKeyboardEvent;\n            break;\n          case 'topBlur':\n          case 'topFocus':\n            EventConstructor = SyntheticFocusEvent;\n            break;\n          case 'topClick':\n            // Firefox creates a click event on right mouse clicks. This removes the\n            // unwanted click events.\n            if (nativeEvent.button === 2) {\n              return null;\n            }\n          /* falls through */\n          case 'topDoubleClick':\n          case 'topMouseDown':\n          case 'topMouseMove':\n          case 'topMouseUp':\n          // TODO: Disabled elements should not respond to mouse events\n          /* falls through */\n          case 'topMouseOut':\n          case 'topMouseOver':\n          case 'topContextMenu':\n            EventConstructor = SyntheticMouseEvent;\n            break;\n          case 'topDrag':\n          case 'topDragEnd':\n          case 'topDragEnter':\n          case 'topDragExit':\n          case 'topDragLeave':\n          case 'topDragOver':\n          case 'topDragStart':\n          case 'topDrop':\n            EventConstructor = SyntheticDragEvent;\n            break;\n          case 'topTouchCancel':\n          case 'topTouchEnd':\n          case 'topTouchMove':\n          case 'topTouchStart':\n            EventConstructor = SyntheticTouchEvent;\n            break;\n          case 'topAnimationEnd':\n          case 'topAnimationIteration':\n          case 'topAnimationStart':\n            EventConstructor = SyntheticAnimationEvent;\n            break;\n          case 'topTransitionEnd':\n            EventConstructor = SyntheticTransitionEvent;\n            break;\n          case 'topScroll':\n            EventConstructor = SyntheticUIEvent;\n            break;\n          case 'topWheel':\n            EventConstructor = SyntheticWheelEvent;\n            break;\n          case 'topCopy':\n          case 'topCut':\n          case 'topPaste':\n            EventConstructor = SyntheticClipboardEvent;\n            break;\n          default:\n            {\n              if (knownHTMLTopLevelTypes.indexOf(topLevelType) === -1) {\n                warning(false, 'SimpleEventPlugin: Unhandled event type, `%s`. This warning ' + 'is likely caused by a bug in React. Please file an issue.', topLevelType);\n              }\n            }\n            // HTML Events\n            // @see http://www.w3.org/TR/html5/index.html#events-0\n            EventConstructor = SyntheticEvent$1;\n            break;\n        }\n        var event = EventConstructor.getPooled(dispatchConfig, targetInst, nativeEvent, nativeEventTarget);\n        accumulateTwoPhaseDispatches(event);\n        return event;\n      }\n    };\n\n    setHandleTopLevel(handleTopLevel);\n\n    /**\n     * Inject modules for resolving DOM hierarchy and plugin ordering.\n     */\n    injection$1.injectEventPluginOrder(DOMEventPluginOrder);\n    injection$2.injectComponentTree(ReactDOMComponentTree);\n\n    /**\n     * Some important event plugins included by default (without having to require\n     * them).\n     */\n    injection$1.injectEventPluginsByName({\n      SimpleEventPlugin: SimpleEventPlugin,\n      EnterLeaveEventPlugin: EnterLeaveEventPlugin,\n      ChangeEventPlugin: ChangeEventPlugin,\n      SelectEventPlugin: SelectEventPlugin,\n      BeforeInputEventPlugin: BeforeInputEventPlugin\n    });\n\n    var enableAsyncSubtreeAPI = true;\n    var enableAsyncSchedulingByDefaultInReactDOM = false;\n    // Exports ReactDOM.createRoot\n    var enableCreateRoot = false;\n    var enableUserTimingAPI = true;\n\n    // Mutating mode (React DOM, React ART, React Native):\n    var enableMutatingReconciler = true;\n    // Experimental noop mode (currently unused):\n    var enableNoopReconciler = false;\n    // Experimental persistent mode (CS):\n    var enablePersistentReconciler = false;\n\n    // Helps identify side effects in begin-phase lifecycle hooks and setState reducers:\n    var debugRenderPhaseSideEffects = false;\n\n    // Only used in www builds.\n\n    var valueStack = [];\n\n    {\n      var fiberStack = [];\n    }\n\n    var index = -1;\n\n    function createCursor(defaultValue) {\n      return {\n        current: defaultValue\n      };\n    }\n\n    function pop(cursor, fiber) {\n      if (index < 0) {\n        {\n          warning(false, 'Unexpected pop.');\n        }\n        return;\n      }\n\n      {\n        if (fiber !== fiberStack[index]) {\n          warning(false, 'Unexpected Fiber popped.');\n        }\n      }\n\n      cursor.current = valueStack[index];\n\n      valueStack[index] = null;\n\n      {\n        fiberStack[index] = null;\n      }\n\n      index--;\n    }\n\n    function push(cursor, value, fiber) {\n      index++;\n\n      valueStack[index] = cursor.current;\n\n      {\n        fiberStack[index] = fiber;\n      }\n\n      cursor.current = value;\n    }\n\n    function reset$1() {\n      while (index > -1) {\n        valueStack[index] = null;\n\n        {\n          fiberStack[index] = null;\n        }\n\n        index--;\n      }\n    }\n\n    var describeComponentFrame = function (name, source, ownerName) {\n      return '\\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');\n    };\n\n    function describeFiber(fiber) {\n      switch (fiber.tag) {\n        case IndeterminateComponent:\n        case FunctionalComponent:\n        case ClassComponent:\n        case HostComponent:\n          var owner = fiber._debugOwner;\n          var source = fiber._debugSource;\n          var name = getComponentName(fiber);\n          var ownerName = null;\n          if (owner) {\n            ownerName = getComponentName(owner);\n          }\n          return describeComponentFrame(name, source, ownerName);\n        default:\n          return '';\n      }\n    }\n\n    // This function can only be called with a work-in-progress fiber and\n    // only during begin or complete phase. Do not call it under any other\n    // circumstances.\n    function getStackAddendumByWorkInProgressFiber(workInProgress) {\n      var info = '';\n      var node = workInProgress;\n      do {\n        info += describeFiber(node);\n        // Otherwise this return pointer might point to the wrong tree:\n        node = node['return'];\n      } while (node);\n      return info;\n    }\n\n    function getCurrentFiberOwnerName() {\n      {\n        var fiber = ReactDebugCurrentFiber.current;\n        if (fiber === null) {\n          return null;\n        }\n        var owner = fiber._debugOwner;\n        if (owner !== null && typeof owner !== 'undefined') {\n          return getComponentName(owner);\n        }\n      }\n      return null;\n    }\n\n    function getCurrentFiberStackAddendum() {\n      {\n        var fiber = ReactDebugCurrentFiber.current;\n        if (fiber === null) {\n          return null;\n        }\n        // Safe because if current fiber exists, we are reconciling,\n        // and it is guaranteed to be the work-in-progress version.\n        return getStackAddendumByWorkInProgressFiber(fiber);\n      }\n      return null;\n    }\n\n    function resetCurrentFiber() {\n      ReactDebugCurrentFrame.getCurrentStack = null;\n      ReactDebugCurrentFiber.current = null;\n      ReactDebugCurrentFiber.phase = null;\n    }\n\n    function setCurrentFiber(fiber) {\n      ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum;\n      ReactDebugCurrentFiber.current = fiber;\n      ReactDebugCurrentFiber.phase = null;\n    }\n\n    function setCurrentPhase(phase) {\n      ReactDebugCurrentFiber.phase = phase;\n    }\n\n    var ReactDebugCurrentFiber = {\n      current: null,\n      phase: null,\n      resetCurrentFiber: resetCurrentFiber,\n      setCurrentFiber: setCurrentFiber,\n      setCurrentPhase: setCurrentPhase,\n      getCurrentFiberOwnerName: getCurrentFiberOwnerName,\n      getCurrentFiberStackAddendum: getCurrentFiberStackAddendum\n    };\n\n    // Prefix measurements so that it's possible to filter them.\n    // Longer prefixes are hard to read in DevTools.\n    var reactEmoji = '\\u269B';\n    var warningEmoji = '\\u26D4';\n    var supportsUserTiming = typeof performance !== 'undefined' && typeof performance.mark === 'function' && typeof performance.clearMarks === 'function' && typeof performance.measure === 'function' && typeof performance.clearMeasures === 'function';\n\n    // Keep track of current fiber so that we know the path to unwind on pause.\n    // TODO: this looks the same as nextUnitOfWork in scheduler. Can we unify them?\n    var currentFiber = null;\n    // If we're in the middle of user code, which fiber and method is it?\n    // Reusing `currentFiber` would be confusing for this because user code fiber\n    // can change during commit phase too, but we don't need to unwind it (since\n    // lifecycles in the commit phase don't resemble a tree).\n    var currentPhase = null;\n    var currentPhaseFiber = null;\n    // Did lifecycle hook schedule an update? This is often a performance problem,\n    // so we will keep track of it, and include it in the report.\n    // Track commits caused by cascading updates.\n    var isCommitting = false;\n    var hasScheduledUpdateInCurrentCommit = false;\n    var hasScheduledUpdateInCurrentPhase = false;\n    var commitCountInCurrentWorkLoop = 0;\n    var effectCountInCurrentCommit = 0;\n    var isWaitingForCallback = false;\n    // During commits, we only show a measurement once per method name\n    // to avoid stretch the commit phase with measurement overhead.\n    var labelsInCurrentCommit = new Set();\n\n    var formatMarkName = function (markName) {\n      return reactEmoji + ' ' + markName;\n    };\n\n    var formatLabel = function (label, warning$$1) {\n      var prefix = warning$$1 ? warningEmoji + ' ' : reactEmoji + ' ';\n      var suffix = warning$$1 ? ' Warning: ' + warning$$1 : '';\n      return '' + prefix + label + suffix;\n    };\n\n    var beginMark = function (markName) {\n      performance.mark(formatMarkName(markName));\n    };\n\n    var clearMark = function (markName) {\n      performance.clearMarks(formatMarkName(markName));\n    };\n\n    var endMark = function (label, markName, warning$$1) {\n      var formattedMarkName = formatMarkName(markName);\n      var formattedLabel = formatLabel(label, warning$$1);\n      try {\n        performance.measure(formattedLabel, formattedMarkName);\n      } catch (err) {}\n      // If previous mark was missing for some reason, this will throw.\n      // This could only happen if React crashed in an unexpected place earlier.\n      // Don't pile on with more errors.\n\n      // Clear marks immediately to avoid growing buffer.\n      performance.clearMarks(formattedMarkName);\n      performance.clearMeasures(formattedLabel);\n    };\n\n    var getFiberMarkName = function (label, debugID) {\n      return label + ' (#' + debugID + ')';\n    };\n\n    var getFiberLabel = function (componentName, isMounted, phase) {\n      if (phase === null) {\n        // These are composite component total time measurements.\n        return componentName + ' [' + (isMounted ? 'update' : 'mount') + ']';\n      } else {\n        // Composite component methods.\n        return componentName + '.' + phase;\n      }\n    };\n\n    var beginFiberMark = function (fiber, phase) {\n      var componentName = getComponentName(fiber) || 'Unknown';\n      var debugID = fiber._debugID;\n      var isMounted = fiber.alternate !== null;\n      var label = getFiberLabel(componentName, isMounted, phase);\n\n      if (isCommitting && labelsInCurrentCommit.has(label)) {\n        // During the commit phase, we don't show duplicate labels because\n        // there is a fixed overhead for every measurement, and we don't\n        // want to stretch the commit phase beyond necessary.\n        return false;\n      }\n      labelsInCurrentCommit.add(label);\n\n      var markName = getFiberMarkName(label, debugID);\n      beginMark(markName);\n      return true;\n    };\n\n    var clearFiberMark = function (fiber, phase) {\n      var componentName = getComponentName(fiber) || 'Unknown';\n      var debugID = fiber._debugID;\n      var isMounted = fiber.alternate !== null;\n      var label = getFiberLabel(componentName, isMounted, phase);\n      var markName = getFiberMarkName(label, debugID);\n      clearMark(markName);\n    };\n\n    var endFiberMark = function (fiber, phase, warning$$1) {\n      var componentName = getComponentName(fiber) || 'Unknown';\n      var debugID = fiber._debugID;\n      var isMounted = fiber.alternate !== null;\n      var label = getFiberLabel(componentName, isMounted, phase);\n      var markName = getFiberMarkName(label, debugID);\n      endMark(label, markName, warning$$1);\n    };\n\n    var shouldIgnoreFiber = function (fiber) {\n      // Host components should be skipped in the timeline.\n      // We could check typeof fiber.type, but does this work with RN?\n      switch (fiber.tag) {\n        case HostRoot:\n        case HostComponent:\n        case HostText:\n        case HostPortal:\n        case ReturnComponent:\n        case Fragment:\n          return true;\n        default:\n          return false;\n      }\n    };\n\n    var clearPendingPhaseMeasurement = function () {\n      if (currentPhase !== null && currentPhaseFiber !== null) {\n        clearFiberMark(currentPhaseFiber, currentPhase);\n      }\n      currentPhaseFiber = null;\n      currentPhase = null;\n      hasScheduledUpdateInCurrentPhase = false;\n    };\n\n    var pauseTimers = function () {\n      // Stops all currently active measurements so that they can be resumed\n      // if we continue in a later deferred loop from the same unit of work.\n      var fiber = currentFiber;\n      while (fiber) {\n        if (fiber._debugIsCurrentlyTiming) {\n          endFiberMark(fiber, null, null);\n        }\n        fiber = fiber['return'];\n      }\n    };\n\n    var resumeTimersRecursively = function (fiber) {\n      if (fiber['return'] !== null) {\n        resumeTimersRecursively(fiber['return']);\n      }\n      if (fiber._debugIsCurrentlyTiming) {\n        beginFiberMark(fiber, null);\n      }\n    };\n\n    var resumeTimers = function () {\n      // Resumes all measurements that were active during the last deferred loop.\n      if (currentFiber !== null) {\n        resumeTimersRecursively(currentFiber);\n      }\n    };\n\n    function recordEffect() {\n      if (enableUserTimingAPI) {\n        effectCountInCurrentCommit++;\n      }\n    }\n\n    function recordScheduleUpdate() {\n      if (enableUserTimingAPI) {\n        if (isCommitting) {\n          hasScheduledUpdateInCurrentCommit = true;\n        }\n        if (currentPhase !== null && currentPhase !== 'componentWillMount' && currentPhase !== 'componentWillReceiveProps') {\n          hasScheduledUpdateInCurrentPhase = true;\n        }\n      }\n    }\n\n    function startRequestCallbackTimer() {\n      if (enableUserTimingAPI) {\n        if (supportsUserTiming && !isWaitingForCallback) {\n          isWaitingForCallback = true;\n          beginMark('(Waiting for async callback...)');\n        }\n      }\n    }\n\n    function stopRequestCallbackTimer(didExpire) {\n      if (enableUserTimingAPI) {\n        if (supportsUserTiming) {\n          isWaitingForCallback = false;\n          var warning$$1 = didExpire ? 'React was blocked by main thread' : null;\n          endMark('(Waiting for async callback...)', '(Waiting for async callback...)', warning$$1);\n        }\n      }\n    }\n\n    function startWorkTimer(fiber) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {\n          return;\n        }\n        // If we pause, this is the fiber to unwind from.\n        currentFiber = fiber;\n        if (!beginFiberMark(fiber, null)) {\n          return;\n        }\n        fiber._debugIsCurrentlyTiming = true;\n      }\n    }\n\n    function cancelWorkTimer(fiber) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {\n          return;\n        }\n        // Remember we shouldn't complete measurement for this fiber.\n        // Otherwise flamechart will be deep even for small updates.\n        fiber._debugIsCurrentlyTiming = false;\n        clearFiberMark(fiber, null);\n      }\n    }\n\n    function stopWorkTimer(fiber) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {\n          return;\n        }\n        // If we pause, its parent is the fiber to unwind from.\n        currentFiber = fiber['return'];\n        if (!fiber._debugIsCurrentlyTiming) {\n          return;\n        }\n        fiber._debugIsCurrentlyTiming = false;\n        endFiberMark(fiber, null, null);\n      }\n    }\n\n    function stopFailedWorkTimer(fiber) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {\n          return;\n        }\n        // If we pause, its parent is the fiber to unwind from.\n        currentFiber = fiber['return'];\n        if (!fiber._debugIsCurrentlyTiming) {\n          return;\n        }\n        fiber._debugIsCurrentlyTiming = false;\n        var warning$$1 = 'An error was thrown inside this error boundary';\n        endFiberMark(fiber, null, warning$$1);\n      }\n    }\n\n    function startPhaseTimer(fiber, phase) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        clearPendingPhaseMeasurement();\n        if (!beginFiberMark(fiber, phase)) {\n          return;\n        }\n        currentPhaseFiber = fiber;\n        currentPhase = phase;\n      }\n    }\n\n    function stopPhaseTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        if (currentPhase !== null && currentPhaseFiber !== null) {\n          var warning$$1 = hasScheduledUpdateInCurrentPhase ? 'Scheduled a cascading update' : null;\n          endFiberMark(currentPhaseFiber, currentPhase, warning$$1);\n        }\n        currentPhase = null;\n        currentPhaseFiber = null;\n      }\n    }\n\n    function startWorkLoopTimer(nextUnitOfWork) {\n      if (enableUserTimingAPI) {\n        currentFiber = nextUnitOfWork;\n        if (!supportsUserTiming) {\n          return;\n        }\n        commitCountInCurrentWorkLoop = 0;\n        // This is top level call.\n        // Any other measurements are performed within.\n        beginMark('(React Tree Reconciliation)');\n        // Resume any measurements that were in progress during the last loop.\n        resumeTimers();\n      }\n    }\n\n    function stopWorkLoopTimer(interruptedBy) {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        var warning$$1 = null;\n        if (interruptedBy !== null) {\n          if (interruptedBy.tag === HostRoot) {\n            warning$$1 = 'A top-level update interrupted the previous render';\n          } else {\n            var componentName = getComponentName(interruptedBy) || 'Unknown';\n            warning$$1 = 'An update to ' + componentName + ' interrupted the previous render';\n          }\n        } else if (commitCountInCurrentWorkLoop > 1) {\n          warning$$1 = 'There were cascading updates';\n        }\n        commitCountInCurrentWorkLoop = 0;\n        // Pause any measurements until the next loop.\n        pauseTimers();\n        endMark('(React Tree Reconciliation)', '(React Tree Reconciliation)', warning$$1);\n      }\n    }\n\n    function startCommitTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        isCommitting = true;\n        hasScheduledUpdateInCurrentCommit = false;\n        labelsInCurrentCommit.clear();\n        beginMark('(Committing Changes)');\n      }\n    }\n\n    function stopCommitTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n\n        var warning$$1 = null;\n        if (hasScheduledUpdateInCurrentCommit) {\n          warning$$1 = 'Lifecycle hook scheduled a cascading update';\n        } else if (commitCountInCurrentWorkLoop > 0) {\n          warning$$1 = 'Caused by a cascading update in earlier commit';\n        }\n        hasScheduledUpdateInCurrentCommit = false;\n        commitCountInCurrentWorkLoop++;\n        isCommitting = false;\n        labelsInCurrentCommit.clear();\n\n        endMark('(Committing Changes)', '(Committing Changes)', warning$$1);\n      }\n    }\n\n    function startCommitHostEffectsTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        effectCountInCurrentCommit = 0;\n        beginMark('(Committing Host Effects)');\n      }\n    }\n\n    function stopCommitHostEffectsTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        var count = effectCountInCurrentCommit;\n        effectCountInCurrentCommit = 0;\n        endMark('(Committing Host Effects: ' + count + ' Total)', '(Committing Host Effects)', null);\n      }\n    }\n\n    function startCommitLifeCyclesTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        effectCountInCurrentCommit = 0;\n        beginMark('(Calling Lifecycle Methods)');\n      }\n    }\n\n    function stopCommitLifeCyclesTimer() {\n      if (enableUserTimingAPI) {\n        if (!supportsUserTiming) {\n          return;\n        }\n        var count = effectCountInCurrentCommit;\n        effectCountInCurrentCommit = 0;\n        endMark('(Calling Lifecycle Methods: ' + count + ' Total)', '(Calling Lifecycle Methods)', null);\n      }\n    }\n\n    {\n      var warnedAboutMissingGetChildContext = {};\n    }\n\n    // A cursor to the current merged context object on the stack.\n    var contextStackCursor = createCursor(emptyObject);\n    // A cursor to a boolean indicating whether the context has changed.\n    var didPerformWorkStackCursor = createCursor(false);\n    // Keep track of the previous context object that was on the stack.\n    // We use this to get access to the parent context after we have already\n    // pushed the next context provider, and now need to merge their contexts.\n    var previousContext = emptyObject;\n\n    function getUnmaskedContext(workInProgress) {\n      var hasOwnContext = isContextProvider(workInProgress);\n      if (hasOwnContext) {\n        // If the fiber is a context provider itself, when we read its context\n        // we have already pushed its own child context on the stack. A context\n        // provider should not \"see\" its own child context. Therefore we read the\n        // previous (parent) context instead for a context provider.\n        return previousContext;\n      }\n      return contextStackCursor.current;\n    }\n\n    function cacheContext(workInProgress, unmaskedContext, maskedContext) {\n      var instance = workInProgress.stateNode;\n      instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;\n      instance.__reactInternalMemoizedMaskedChildContext = maskedContext;\n    }\n\n    function getMaskedContext(workInProgress, unmaskedContext) {\n      var type = workInProgress.type;\n      var contextTypes = type.contextTypes;\n      if (!contextTypes) {\n        return emptyObject;\n      }\n\n      // Avoid recreating masked context unless unmasked context has changed.\n      // Failing to do this will result in unnecessary calls to componentWillReceiveProps.\n      // This may trigger infinite loops if componentWillReceiveProps calls setState.\n      var instance = workInProgress.stateNode;\n      if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {\n        return instance.__reactInternalMemoizedMaskedChildContext;\n      }\n\n      var context = {};\n      for (var key in contextTypes) {\n        context[key] = unmaskedContext[key];\n      }\n\n      {\n        var name = getComponentName(workInProgress) || 'Unknown';\n        checkPropTypes(contextTypes, context, 'context', name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum);\n      }\n\n      // Cache unmasked context so we can avoid recreating masked context unless necessary.\n      // Context is created before the class component is instantiated so check for instance.\n      if (instance) {\n        cacheContext(workInProgress, unmaskedContext, context);\n      }\n\n      return context;\n    }\n\n    function hasContextChanged() {\n      return didPerformWorkStackCursor.current;\n    }\n\n    function isContextConsumer(fiber) {\n      return fiber.tag === ClassComponent && fiber.type.contextTypes != null;\n    }\n\n    function isContextProvider(fiber) {\n      return fiber.tag === ClassComponent && fiber.type.childContextTypes != null;\n    }\n\n    function popContextProvider(fiber) {\n      if (!isContextProvider(fiber)) {\n        return;\n      }\n\n      pop(didPerformWorkStackCursor, fiber);\n      pop(contextStackCursor, fiber);\n    }\n\n    function popTopLevelContextObject(fiber) {\n      pop(didPerformWorkStackCursor, fiber);\n      pop(contextStackCursor, fiber);\n    }\n\n    function pushTopLevelContextObject(fiber, context, didChange) {\n      !(contextStackCursor.cursor == null) ? invariant(false, 'Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n      push(contextStackCursor, context, fiber);\n      push(didPerformWorkStackCursor, didChange, fiber);\n    }\n\n    function processChildContext(fiber, parentContext) {\n      var instance = fiber.stateNode;\n      var childContextTypes = fiber.type.childContextTypes;\n\n      // TODO (bvaughn) Replace this behavior with an invariant() in the future.\n      // It has only been added in Fiber to match the (unintentional) behavior in Stack.\n      if (typeof instance.getChildContext !== 'function') {\n        {\n          var componentName = getComponentName(fiber) || 'Unknown';\n\n          if (!warnedAboutMissingGetChildContext[componentName]) {\n            warnedAboutMissingGetChildContext[componentName] = true;\n            warning(false, '%s.childContextTypes is specified but there is no getChildContext() method ' + 'on the instance. You can either define getChildContext() on %s or remove ' + 'childContextTypes from it.', componentName, componentName);\n          }\n        }\n        return parentContext;\n      }\n\n      var childContext = void 0;\n      {\n        ReactDebugCurrentFiber.setCurrentPhase('getChildContext');\n      }\n      startPhaseTimer(fiber, 'getChildContext');\n      childContext = instance.getChildContext();\n      stopPhaseTimer();\n      {\n        ReactDebugCurrentFiber.setCurrentPhase(null);\n      }\n      for (var contextKey in childContext) {\n        !(contextKey in childContextTypes) ? invariant(false, '%s.getChildContext(): key \"%s\" is not defined in childContextTypes.', getComponentName(fiber) || 'Unknown', contextKey) : void 0;\n      }\n      {\n        var name = getComponentName(fiber) || 'Unknown';\n        checkPropTypes(childContextTypes, childContext, 'child context', name,\n        // In practice, there is one case in which we won't get a stack. It's when\n        // somebody calls unstable_renderSubtreeIntoContainer() and we process\n        // context from the parent component instance. The stack will be missing\n        // because it's outside of the reconciliation, and so the pointer has not\n        // been set. This is rare and doesn't matter. We'll also remove that API.\n        ReactDebugCurrentFiber.getCurrentFiberStackAddendum);\n      }\n\n      return _assign({}, parentContext, childContext);\n    }\n\n    function pushContextProvider(workInProgress) {\n      if (!isContextProvider(workInProgress)) {\n        return false;\n      }\n\n      var instance = workInProgress.stateNode;\n      // We push the context as early as possible to ensure stack integrity.\n      // If the instance does not exist yet, we will push null at first,\n      // and replace it on the stack later when invalidating the context.\n      var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;\n\n      // Remember the parent context so we can merge with it later.\n      // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.\n      previousContext = contextStackCursor.current;\n      push(contextStackCursor, memoizedMergedChildContext, workInProgress);\n      push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);\n\n      return true;\n    }\n\n    function invalidateContextProvider(workInProgress, didChange) {\n      var instance = workInProgress.stateNode;\n      !instance ? invariant(false, 'Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n      if (didChange) {\n        // Merge parent and own context.\n        // Skip this if we're not updating due to sCU.\n        // This avoids unnecessarily recomputing memoized values.\n        var mergedContext = processChildContext(workInProgress, previousContext);\n        instance.__reactInternalMemoizedMergedChildContext = mergedContext;\n\n        // Replace the old (or empty) context with the new one.\n        // It is important to unwind the context in the reverse order.\n        pop(didPerformWorkStackCursor, workInProgress);\n        pop(contextStackCursor, workInProgress);\n        // Now push the new context and mark that it has changed.\n        push(contextStackCursor, mergedContext, workInProgress);\n        push(didPerformWorkStackCursor, didChange, workInProgress);\n      } else {\n        pop(didPerformWorkStackCursor, workInProgress);\n        push(didPerformWorkStackCursor, didChange, workInProgress);\n      }\n    }\n\n    function resetContext() {\n      previousContext = emptyObject;\n      contextStackCursor.current = emptyObject;\n      didPerformWorkStackCursor.current = false;\n    }\n\n    function findCurrentUnmaskedContext(fiber) {\n      // Currently this is only used with renderSubtreeIntoContainer; not sure if it\n      // makes sense elsewhere\n      !(isFiberMounted(fiber) && fiber.tag === ClassComponent) ? invariant(false, 'Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n      var node = fiber;\n      while (node.tag !== HostRoot) {\n        if (isContextProvider(node)) {\n          return node.stateNode.__reactInternalMemoizedMergedChildContext;\n        }\n        var parent = node['return'];\n        !parent ? invariant(false, 'Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        node = parent;\n      }\n      return node.stateNode.context;\n    }\n\n    var NoWork = 0; // TODO: Use an opaque type once ESLint et al support the syntax\n\n    var Sync = 1;\n    var Never = 2147483647; // Max int32: Math.pow(2, 31) - 1\n\n    var UNIT_SIZE = 10;\n    var MAGIC_NUMBER_OFFSET = 2;\n\n    // 1 unit of expiration time represents 10ms.\n    function msToExpirationTime(ms) {\n      // Always add an offset so that we don't clash with the magic number for NoWork.\n      return (ms / UNIT_SIZE | 0) + MAGIC_NUMBER_OFFSET;\n    }\n\n    function expirationTimeToMs(expirationTime) {\n      return (expirationTime - MAGIC_NUMBER_OFFSET) * UNIT_SIZE;\n    }\n\n    function ceiling(num, precision) {\n      return ((num / precision | 0) + 1) * precision;\n    }\n\n    function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {\n      return ceiling(currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);\n    }\n\n    var NoContext = 0;\n    var AsyncUpdates = 1;\n\n    {\n      var hasBadMapPolyfill = false;\n      try {\n        var nonExtensibleObject = Object.preventExtensions({});\n        /* eslint-disable no-new */\n\n        /* eslint-enable no-new */\n      } catch (e) {\n        // TODO: Consider warning about bad polyfills\n        hasBadMapPolyfill = true;\n      }\n    }\n\n    // A Fiber is work on a Component that needs to be done or was done. There can\n    // be more than one per component.\n\n\n    {\n      var debugCounter = 1;\n    }\n\n    function FiberNode(tag, key, internalContextTag) {\n      // Instance\n      this.tag = tag;\n      this.key = key;\n      this.type = null;\n      this.stateNode = null;\n\n      // Fiber\n      this['return'] = null;\n      this.child = null;\n      this.sibling = null;\n      this.index = 0;\n\n      this.ref = null;\n\n      this.pendingProps = null;\n      this.memoizedProps = null;\n      this.updateQueue = null;\n      this.memoizedState = null;\n\n      this.internalContextTag = internalContextTag;\n\n      // Effects\n      this.effectTag = NoEffect;\n      this.nextEffect = null;\n\n      this.firstEffect = null;\n      this.lastEffect = null;\n\n      this.expirationTime = NoWork;\n\n      this.alternate = null;\n\n      {\n        this._debugID = debugCounter++;\n        this._debugSource = null;\n        this._debugOwner = null;\n        this._debugIsCurrentlyTiming = false;\n        if (!hasBadMapPolyfill && typeof Object.preventExtensions === 'function') {\n          Object.preventExtensions(this);\n        }\n      }\n    }\n\n    // This is a constructor function, rather than a POJO constructor, still\n    // please ensure we do the following:\n    // 1) Nobody should add any instance methods on this. Instance methods can be\n    //    more difficult to predict when they get optimized and they are almost\n    //    never inlined properly in static compilers.\n    // 2) Nobody should rely on `instanceof Fiber` for type testing. We should\n    //    always know when it is a fiber.\n    // 3) We might want to experiment with using numeric keys since they are easier\n    //    to optimize in a non-JIT environment.\n    // 4) We can easily go from a constructor to a createFiber object literal if that\n    //    is faster.\n    // 5) It should be easy to port this to a C struct and keep a C implementation\n    //    compatible.\n    var createFiber = function (tag, key, internalContextTag) {\n      // $FlowFixMe: the shapes are exact here but Flow doesn't like constructors\n      return new FiberNode(tag, key, internalContextTag);\n    };\n\n    function shouldConstruct(Component) {\n      return !!(Component.prototype && Component.prototype.isReactComponent);\n    }\n\n    // This is used to create an alternate fiber to do work on.\n    function createWorkInProgress(current, pendingProps, expirationTime) {\n      var workInProgress = current.alternate;\n      if (workInProgress === null) {\n        // We use a double buffering pooling technique because we know that we'll\n        // only ever need at most two versions of a tree. We pool the \"other\" unused\n        // node that we're free to reuse. This is lazily created to avoid allocating\n        // extra objects for things that are never updated. It also allow us to\n        // reclaim the extra memory if needed.\n        workInProgress = createFiber(current.tag, current.key, current.internalContextTag);\n        workInProgress.type = current.type;\n        workInProgress.stateNode = current.stateNode;\n\n        {\n          // DEV-only fields\n          workInProgress._debugID = current._debugID;\n          workInProgress._debugSource = current._debugSource;\n          workInProgress._debugOwner = current._debugOwner;\n        }\n\n        workInProgress.alternate = current;\n        current.alternate = workInProgress;\n      } else {\n        // We already have an alternate.\n        // Reset the effect tag.\n        workInProgress.effectTag = NoEffect;\n\n        // The effect list is no longer valid.\n        workInProgress.nextEffect = null;\n        workInProgress.firstEffect = null;\n        workInProgress.lastEffect = null;\n      }\n\n      workInProgress.expirationTime = expirationTime;\n      workInProgress.pendingProps = pendingProps;\n\n      workInProgress.child = current.child;\n      workInProgress.memoizedProps = current.memoizedProps;\n      workInProgress.memoizedState = current.memoizedState;\n      workInProgress.updateQueue = current.updateQueue;\n\n      // These will be overridden during the parent's reconciliation\n      workInProgress.sibling = current.sibling;\n      workInProgress.index = current.index;\n      workInProgress.ref = current.ref;\n\n      return workInProgress;\n    }\n\n    function createHostRootFiber() {\n      var fiber = createFiber(HostRoot, null, NoContext);\n      return fiber;\n    }\n\n    function createFiberFromElement(element, internalContextTag, expirationTime) {\n      var owner = null;\n      {\n        owner = element._owner;\n      }\n\n      var fiber = void 0;\n      var type = element.type,\n          key = element.key;\n\n      if (typeof type === 'function') {\n        fiber = shouldConstruct(type) ? createFiber(ClassComponent, key, internalContextTag) : createFiber(IndeterminateComponent, key, internalContextTag);\n        fiber.type = type;\n        fiber.pendingProps = element.props;\n      } else if (typeof type === 'string') {\n        fiber = createFiber(HostComponent, key, internalContextTag);\n        fiber.type = type;\n        fiber.pendingProps = element.props;\n      } else if (typeof type === 'object' && type !== null && typeof type.tag === 'number') {\n        // Currently assumed to be a continuation and therefore is a fiber already.\n        // TODO: The yield system is currently broken for updates in some cases.\n        // The reified yield stores a fiber, but we don't know which fiber that is;\n        // the current or a workInProgress? When the continuation gets rendered here\n        // we don't know if we can reuse that fiber or if we need to clone it.\n        // There is probably a clever way to restructure this.\n        fiber = type;\n        fiber.pendingProps = element.props;\n      } else {\n        var info = '';\n        {\n          if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {\n            info += ' You likely forgot to export your component from the file ' + \"it's defined in, or you might have mixed up default and named imports.\";\n          }\n          var ownerName = owner ? getComponentName(owner) : null;\n          if (ownerName) {\n            info += '\\n\\nCheck the render method of `' + ownerName + '`.';\n          }\n        }\n        invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', type == null ? type : typeof type, info);\n      }\n\n      {\n        fiber._debugSource = element._source;\n        fiber._debugOwner = element._owner;\n      }\n\n      fiber.expirationTime = expirationTime;\n\n      return fiber;\n    }\n\n    function createFiberFromFragment(elements, internalContextTag, expirationTime, key) {\n      var fiber = createFiber(Fragment, key, internalContextTag);\n      fiber.pendingProps = elements;\n      fiber.expirationTime = expirationTime;\n      return fiber;\n    }\n\n    function createFiberFromText(content, internalContextTag, expirationTime) {\n      var fiber = createFiber(HostText, null, internalContextTag);\n      fiber.pendingProps = content;\n      fiber.expirationTime = expirationTime;\n      return fiber;\n    }\n\n    function createFiberFromHostInstanceForDeletion() {\n      var fiber = createFiber(HostComponent, null, NoContext);\n      fiber.type = 'DELETED';\n      return fiber;\n    }\n\n    function createFiberFromCall(call, internalContextTag, expirationTime) {\n      var fiber = createFiber(CallComponent, call.key, internalContextTag);\n      fiber.type = call.handler;\n      fiber.pendingProps = call;\n      fiber.expirationTime = expirationTime;\n      return fiber;\n    }\n\n    function createFiberFromReturn(returnNode, internalContextTag, expirationTime) {\n      var fiber = createFiber(ReturnComponent, null, internalContextTag);\n      fiber.expirationTime = expirationTime;\n      return fiber;\n    }\n\n    function createFiberFromPortal(portal, internalContextTag, expirationTime) {\n      var fiber = createFiber(HostPortal, portal.key, internalContextTag);\n      fiber.pendingProps = portal.children || [];\n      fiber.expirationTime = expirationTime;\n      fiber.stateNode = {\n        containerInfo: portal.containerInfo,\n        pendingChildren: null, // Used by persistent updates\n        implementation: portal.implementation\n      };\n      return fiber;\n    }\n\n    function createFiberRoot(containerInfo, hydrate) {\n      // Cyclic construction. This cheats the type system right now because\n      // stateNode is any.\n      var uninitializedFiber = createHostRootFiber();\n      var root = {\n        current: uninitializedFiber,\n        containerInfo: containerInfo,\n        pendingChildren: null,\n        remainingExpirationTime: NoWork,\n        isReadyForCommit: false,\n        finishedWork: null,\n        context: null,\n        pendingContext: null,\n        hydrate: hydrate,\n        nextScheduledRoot: null\n      };\n      uninitializedFiber.stateNode = root;\n      return root;\n    }\n\n    var onCommitFiberRoot = null;\n    var onCommitFiberUnmount = null;\n    var hasLoggedError = false;\n\n    function catchErrors(fn) {\n      return function (arg) {\n        try {\n          return fn(arg);\n        } catch (err) {\n          if (true && !hasLoggedError) {\n            hasLoggedError = true;\n            warning(false, 'React DevTools encountered an error: %s', err);\n          }\n        }\n      };\n    }\n\n    function injectInternals(internals) {\n      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {\n        // No DevTools\n        return false;\n      }\n      var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;\n      if (hook.isDisabled) {\n        // This isn't a real property on the hook, but it can be set to opt out\n        // of DevTools integration and associated warnings and logs.\n        // https://github.com/facebook/react/issues/3877\n        return true;\n      }\n      if (!hook.supportsFiber) {\n        {\n          warning(false, 'The installed version of React DevTools is too old and will not work ' + 'with the current version of React. Please update React DevTools. ' + 'https://fb.me/react-devtools');\n        }\n        // DevTools exists, even though it doesn't support Fiber.\n        return true;\n      }\n      try {\n        var rendererID = hook.inject(internals);\n        // We have successfully injected, so now it is safe to set up hooks.\n        onCommitFiberRoot = catchErrors(function (root) {\n          return hook.onCommitFiberRoot(rendererID, root);\n        });\n        onCommitFiberUnmount = catchErrors(function (fiber) {\n          return hook.onCommitFiberUnmount(rendererID, fiber);\n        });\n      } catch (err) {\n        // Catch all errors because it is unsafe to throw during initialization.\n        {\n          warning(false, 'React DevTools encountered an error: %s.', err);\n        }\n      }\n      // DevTools exists\n      return true;\n    }\n\n    function onCommitRoot(root) {\n      if (typeof onCommitFiberRoot === 'function') {\n        onCommitFiberRoot(root);\n      }\n    }\n\n    function onCommitUnmount(fiber) {\n      if (typeof onCommitFiberUnmount === 'function') {\n        onCommitFiberUnmount(fiber);\n      }\n    }\n\n    {\n      var didWarnUpdateInsideUpdate = false;\n    }\n\n    // Callbacks are not validated until invocation\n\n\n    // Singly linked-list of updates. When an update is scheduled, it is added to\n    // the queue of the current fiber and the work-in-progress fiber. The two queues\n    // are separate but they share a persistent structure.\n    //\n    // During reconciliation, updates are removed from the work-in-progress fiber,\n    // but they remain on the current fiber. That ensures that if a work-in-progress\n    // is aborted, the aborted updates are recovered by cloning from current.\n    //\n    // The work-in-progress queue is always a subset of the current queue.\n    //\n    // When the tree is committed, the work-in-progress becomes the current.\n\n\n    function createUpdateQueue(baseState) {\n      var queue = {\n        baseState: baseState,\n        expirationTime: NoWork,\n        first: null,\n        last: null,\n        callbackList: null,\n        hasForceUpdate: false,\n        isInitialized: false\n      };\n      {\n        queue.isProcessing = false;\n      }\n      return queue;\n    }\n\n    function insertUpdateIntoQueue(queue, update) {\n      // Append the update to the end of the list.\n      if (queue.last === null) {\n        // Queue is empty\n        queue.first = queue.last = update;\n      } else {\n        queue.last.next = update;\n        queue.last = update;\n      }\n      if (queue.expirationTime === NoWork || queue.expirationTime > update.expirationTime) {\n        queue.expirationTime = update.expirationTime;\n      }\n    }\n\n    function insertUpdateIntoFiber(fiber, update) {\n      // We'll have at least one and at most two distinct update queues.\n      var alternateFiber = fiber.alternate;\n      var queue1 = fiber.updateQueue;\n      if (queue1 === null) {\n        // TODO: We don't know what the base state will be until we begin work.\n        // It depends on which fiber is the next current. Initialize with an empty\n        // base state, then set to the memoizedState when rendering. Not super\n        // happy with this approach.\n        queue1 = fiber.updateQueue = createUpdateQueue(null);\n      }\n\n      var queue2 = void 0;\n      if (alternateFiber !== null) {\n        queue2 = alternateFiber.updateQueue;\n        if (queue2 === null) {\n          queue2 = alternateFiber.updateQueue = createUpdateQueue(null);\n        }\n      } else {\n        queue2 = null;\n      }\n      queue2 = queue2 !== queue1 ? queue2 : null;\n\n      // Warn if an update is scheduled from inside an updater function.\n      {\n        if ((queue1.isProcessing || queue2 !== null && queue2.isProcessing) && !didWarnUpdateInsideUpdate) {\n          warning(false, 'An update (setState, replaceState, or forceUpdate) was scheduled ' + 'from inside an update function. Update functions should be pure, ' + 'with zero side-effects. Consider using componentDidUpdate or a ' + 'callback.');\n          didWarnUpdateInsideUpdate = true;\n        }\n      }\n\n      // If there's only one queue, add the update to that queue and exit.\n      if (queue2 === null) {\n        insertUpdateIntoQueue(queue1, update);\n        return;\n      }\n\n      // If either queue is empty, we need to add to both queues.\n      if (queue1.last === null || queue2.last === null) {\n        insertUpdateIntoQueue(queue1, update);\n        insertUpdateIntoQueue(queue2, update);\n        return;\n      }\n\n      // If both lists are not empty, the last update is the same for both lists\n      // because of structural sharing. So, we should only append to one of\n      // the lists.\n      insertUpdateIntoQueue(queue1, update);\n      // But we still need to update the `last` pointer of queue2.\n      queue2.last = update;\n    }\n\n    function getUpdateExpirationTime(fiber) {\n      if (fiber.tag !== ClassComponent && fiber.tag !== HostRoot) {\n        return NoWork;\n      }\n      var updateQueue = fiber.updateQueue;\n      if (updateQueue === null) {\n        return NoWork;\n      }\n      return updateQueue.expirationTime;\n    }\n\n    function getStateFromUpdate(update, instance, prevState, props) {\n      var partialState = update.partialState;\n      if (typeof partialState === 'function') {\n        var updateFn = partialState;\n\n        // Invoke setState callback an extra time to help detect side-effects.\n        if (debugRenderPhaseSideEffects) {\n          updateFn.call(instance, prevState, props);\n        }\n\n        return updateFn.call(instance, prevState, props);\n      } else {\n        return partialState;\n      }\n    }\n\n    function processUpdateQueue(current, workInProgress, queue, instance, props, renderExpirationTime) {\n      if (current !== null && current.updateQueue === queue) {\n        // We need to create a work-in-progress queue, by cloning the current queue.\n        var currentQueue = queue;\n        queue = workInProgress.updateQueue = {\n          baseState: currentQueue.baseState,\n          expirationTime: currentQueue.expirationTime,\n          first: currentQueue.first,\n          last: currentQueue.last,\n          isInitialized: currentQueue.isInitialized,\n          // These fields are no longer valid because they were already committed.\n          // Reset them.\n          callbackList: null,\n          hasForceUpdate: false\n        };\n      }\n\n      {\n        // Set this flag so we can warn if setState is called inside the update\n        // function of another setState.\n        queue.isProcessing = true;\n      }\n\n      // Reset the remaining expiration time. If we skip over any updates, we'll\n      // increase this accordingly.\n      queue.expirationTime = NoWork;\n\n      // TODO: We don't know what the base state will be until we begin work.\n      // It depends on which fiber is the next current. Initialize with an empty\n      // base state, then set to the memoizedState when rendering. Not super\n      // happy with this approach.\n      var state = void 0;\n      if (queue.isInitialized) {\n        state = queue.baseState;\n      } else {\n        state = queue.baseState = workInProgress.memoizedState;\n        queue.isInitialized = true;\n      }\n      var dontMutatePrevState = true;\n      var update = queue.first;\n      var didSkip = false;\n      while (update !== null) {\n        var updateExpirationTime = update.expirationTime;\n        if (updateExpirationTime > renderExpirationTime) {\n          // This update does not have sufficient priority. Skip it.\n          var remainingExpirationTime = queue.expirationTime;\n          if (remainingExpirationTime === NoWork || remainingExpirationTime > updateExpirationTime) {\n            // Update the remaining expiration time.\n            queue.expirationTime = updateExpirationTime;\n          }\n          if (!didSkip) {\n            didSkip = true;\n            queue.baseState = state;\n          }\n          // Continue to the next update.\n          update = update.next;\n          continue;\n        }\n\n        // This update does have sufficient priority.\n\n        // If no previous updates were skipped, drop this update from the queue by\n        // advancing the head of the list.\n        if (!didSkip) {\n          queue.first = update.next;\n          if (queue.first === null) {\n            queue.last = null;\n          }\n        }\n\n        // Process the update\n        var _partialState = void 0;\n        if (update.isReplace) {\n          state = getStateFromUpdate(update, instance, state, props);\n          dontMutatePrevState = true;\n        } else {\n          _partialState = getStateFromUpdate(update, instance, state, props);\n          if (_partialState) {\n            if (dontMutatePrevState) {\n              // $FlowFixMe: Idk how to type this properly.\n              state = _assign({}, state, _partialState);\n            } else {\n              state = _assign(state, _partialState);\n            }\n            dontMutatePrevState = false;\n          }\n        }\n        if (update.isForced) {\n          queue.hasForceUpdate = true;\n        }\n        if (update.callback !== null) {\n          // Append to list of callbacks.\n          var _callbackList = queue.callbackList;\n          if (_callbackList === null) {\n            _callbackList = queue.callbackList = [];\n          }\n          _callbackList.push(update);\n        }\n        update = update.next;\n      }\n\n      if (queue.callbackList !== null) {\n        workInProgress.effectTag |= Callback;\n      } else if (queue.first === null && !queue.hasForceUpdate) {\n        // The queue is empty. We can reset it.\n        workInProgress.updateQueue = null;\n      }\n\n      if (!didSkip) {\n        didSkip = true;\n        queue.baseState = state;\n      }\n\n      {\n        // No longer processing.\n        queue.isProcessing = false;\n      }\n\n      return state;\n    }\n\n    function commitCallbacks(queue, context) {\n      var callbackList = queue.callbackList;\n      if (callbackList === null) {\n        return;\n      }\n      // Set the list to null to make sure they don't get called more than once.\n      queue.callbackList = null;\n      for (var i = 0; i < callbackList.length; i++) {\n        var update = callbackList[i];\n        var _callback = update.callback;\n        // This update might be processed again. Clear the callback so it's only\n        // called once.\n        update.callback = null;\n        !(typeof _callback === 'function') ? invariant(false, 'Invalid argument passed as callback. Expected a function. Instead received: %s', _callback) : void 0;\n        _callback.call(context);\n      }\n    }\n\n    var fakeInternalInstance = {};\n    var isArray = Array.isArray;\n\n    {\n      var didWarnAboutStateAssignmentForComponent = {};\n\n      var warnOnInvalidCallback = function (callback, callerName) {\n        warning(callback === null || typeof callback === 'function', '%s(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callerName, callback);\n      };\n\n      // This is so gross but it's at least non-critical and can be removed if\n      // it causes problems. This is meant to give a nicer error message for\n      // ReactDOM15.unstable_renderSubtreeIntoContainer(reactDOM16Component,\n      // ...)) which otherwise throws a \"_processChildContext is not a function\"\n      // exception.\n      Object.defineProperty(fakeInternalInstance, '_processChildContext', {\n        enumerable: false,\n        value: function () {\n          invariant(false, '_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn\\'t supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal).');\n        }\n      });\n      Object.freeze(fakeInternalInstance);\n    }\n\n    var ReactFiberClassComponent = function (scheduleWork, computeExpirationForFiber, memoizeProps, memoizeState) {\n      // Class component state updater\n      var updater = {\n        isMounted: isMounted,\n        enqueueSetState: function (instance, partialState, callback) {\n          var fiber = get(instance);\n          callback = callback === undefined ? null : callback;\n          {\n            warnOnInvalidCallback(callback, 'setState');\n          }\n          var expirationTime = computeExpirationForFiber(fiber);\n          var update = {\n            expirationTime: expirationTime,\n            partialState: partialState,\n            callback: callback,\n            isReplace: false,\n            isForced: false,\n            nextCallback: null,\n            next: null\n          };\n          insertUpdateIntoFiber(fiber, update);\n          scheduleWork(fiber, expirationTime);\n        },\n        enqueueReplaceState: function (instance, state, callback) {\n          var fiber = get(instance);\n          callback = callback === undefined ? null : callback;\n          {\n            warnOnInvalidCallback(callback, 'replaceState');\n          }\n          var expirationTime = computeExpirationForFiber(fiber);\n          var update = {\n            expirationTime: expirationTime,\n            partialState: state,\n            callback: callback,\n            isReplace: true,\n            isForced: false,\n            nextCallback: null,\n            next: null\n          };\n          insertUpdateIntoFiber(fiber, update);\n          scheduleWork(fiber, expirationTime);\n        },\n        enqueueForceUpdate: function (instance, callback) {\n          var fiber = get(instance);\n          callback = callback === undefined ? null : callback;\n          {\n            warnOnInvalidCallback(callback, 'forceUpdate');\n          }\n          var expirationTime = computeExpirationForFiber(fiber);\n          var update = {\n            expirationTime: expirationTime,\n            partialState: null,\n            callback: callback,\n            isReplace: false,\n            isForced: true,\n            nextCallback: null,\n            next: null\n          };\n          insertUpdateIntoFiber(fiber, update);\n          scheduleWork(fiber, expirationTime);\n        }\n      };\n\n      function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {\n        if (oldProps === null || workInProgress.updateQueue !== null && workInProgress.updateQueue.hasForceUpdate) {\n          // If the workInProgress already has an Update effect, return true\n          return true;\n        }\n\n        var instance = workInProgress.stateNode;\n        var type = workInProgress.type;\n        if (typeof instance.shouldComponentUpdate === 'function') {\n          startPhaseTimer(workInProgress, 'shouldComponentUpdate');\n          var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext);\n          stopPhaseTimer();\n\n          // Simulate an async bailout/interruption by invoking lifecycle twice.\n          if (debugRenderPhaseSideEffects) {\n            instance.shouldComponentUpdate(newProps, newState, newContext);\n          }\n\n          {\n            warning(shouldUpdate !== undefined, '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', getComponentName(workInProgress) || 'Unknown');\n          }\n\n          return shouldUpdate;\n        }\n\n        if (type.prototype && type.prototype.isPureReactComponent) {\n          return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);\n        }\n\n        return true;\n      }\n\n      function checkClassInstance(workInProgress) {\n        var instance = workInProgress.stateNode;\n        var type = workInProgress.type;\n        {\n          var name = getComponentName(workInProgress);\n          var renderPresent = instance.render;\n\n          if (!renderPresent) {\n            if (type.prototype && typeof type.prototype.render === 'function') {\n              warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: did you accidentally return an object from the constructor?', name);\n            } else {\n              warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`.', name);\n            }\n          }\n\n          var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;\n          warning(noGetInitialStateOnES6, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', name);\n          var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;\n          warning(noGetDefaultPropsOnES6, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', name);\n          var noInstancePropTypes = !instance.propTypes;\n          warning(noInstancePropTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', name);\n          var noInstanceContextTypes = !instance.contextTypes;\n          warning(noInstanceContextTypes, 'contextTypes was defined as an instance property on %s. Use a static ' + 'property to define contextTypes instead.', name);\n          var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== 'function';\n          warning(noComponentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', name);\n          if (type.prototype && type.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== 'undefined') {\n            warning(false, '%s has a method called shouldComponentUpdate(). ' + 'shouldComponentUpdate should not be used when extending React.PureComponent. ' + 'Please extend React.Component if shouldComponentUpdate is used.', getComponentName(workInProgress) || 'A pure component');\n          }\n          var noComponentDidUnmount = typeof instance.componentDidUnmount !== 'function';\n          warning(noComponentDidUnmount, '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', name);\n          var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== 'function';\n          warning(noComponentDidReceiveProps, '%s has a method called ' + 'componentDidReceiveProps(). But there is no such lifecycle method. ' + 'If you meant to update the state in response to changing props, ' + 'use componentWillReceiveProps(). If you meant to fetch data or ' + 'run side-effects or mutations after React has updated the UI, use componentDidUpdate().', name);\n          var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== 'function';\n          warning(noComponentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', name);\n          var hasMutatedProps = instance.props !== workInProgress.pendingProps;\n          warning(instance.props === undefined || !hasMutatedProps, '%s(...): When calling super() in `%s`, make sure to pass ' + \"up the same props that your component's constructor was passed.\", name, name);\n          var noInstanceDefaultProps = !instance.defaultProps;\n          warning(noInstanceDefaultProps, 'Setting defaultProps as an instance property on %s is not supported and will be ignored.' + ' Instead, define defaultProps as a static property on %s.', name, name);\n        }\n\n        var state = instance.state;\n        if (state && (typeof state !== 'object' || isArray(state))) {\n          warning(false, '%s.state: must be set to an object or null', getComponentName(workInProgress));\n        }\n        if (typeof instance.getChildContext === 'function') {\n          warning(typeof workInProgress.type.childContextTypes === 'object', '%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', getComponentName(workInProgress));\n        }\n      }\n\n      function resetInputPointers(workInProgress, instance) {\n        instance.props = workInProgress.memoizedProps;\n        instance.state = workInProgress.memoizedState;\n      }\n\n      function adoptClassInstance(workInProgress, instance) {\n        instance.updater = updater;\n        workInProgress.stateNode = instance;\n        // The instance needs access to the fiber so that it can schedule updates\n        set(instance, workInProgress);\n        {\n          instance._reactInternalInstance = fakeInternalInstance;\n        }\n      }\n\n      function constructClassInstance(workInProgress, props) {\n        var ctor = workInProgress.type;\n        var unmaskedContext = getUnmaskedContext(workInProgress);\n        var needsContext = isContextConsumer(workInProgress);\n        var context = needsContext ? getMaskedContext(workInProgress, unmaskedContext) : emptyObject;\n        var instance = new ctor(props, context);\n        adoptClassInstance(workInProgress, instance);\n\n        // Cache unmasked context so we can avoid recreating masked context unless necessary.\n        // ReactFiberContext usually updates this cache but can't for newly-created instances.\n        if (needsContext) {\n          cacheContext(workInProgress, unmaskedContext, context);\n        }\n\n        return instance;\n      }\n\n      function callComponentWillMount(workInProgress, instance) {\n        startPhaseTimer(workInProgress, 'componentWillMount');\n        var oldState = instance.state;\n        instance.componentWillMount();\n        stopPhaseTimer();\n\n        // Simulate an async bailout/interruption by invoking lifecycle twice.\n        if (debugRenderPhaseSideEffects) {\n          instance.componentWillMount();\n        }\n\n        if (oldState !== instance.state) {\n          {\n            warning(false, '%s.componentWillMount(): Assigning directly to this.state is ' + \"deprecated (except inside a component's \" + 'constructor). Use setState instead.', getComponentName(workInProgress));\n          }\n          updater.enqueueReplaceState(instance, instance.state, null);\n        }\n      }\n\n      function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {\n        startPhaseTimer(workInProgress, 'componentWillReceiveProps');\n        var oldState = instance.state;\n        instance.componentWillReceiveProps(newProps, newContext);\n        stopPhaseTimer();\n\n        // Simulate an async bailout/interruption by invoking lifecycle twice.\n        if (debugRenderPhaseSideEffects) {\n          instance.componentWillReceiveProps(newProps, newContext);\n        }\n\n        if (instance.state !== oldState) {\n          {\n            var componentName = getComponentName(workInProgress) || 'Component';\n            if (!didWarnAboutStateAssignmentForComponent[componentName]) {\n              warning(false, '%s.componentWillReceiveProps(): Assigning directly to ' + \"this.state is deprecated (except inside a component's \" + 'constructor). Use setState instead.', componentName);\n              didWarnAboutStateAssignmentForComponent[componentName] = true;\n            }\n          }\n          updater.enqueueReplaceState(instance, instance.state, null);\n        }\n      }\n\n      // Invokes the mount life-cycles on a previously never rendered instance.\n      function mountClassInstance(workInProgress, renderExpirationTime) {\n        var current = workInProgress.alternate;\n\n        {\n          checkClassInstance(workInProgress);\n        }\n\n        var instance = workInProgress.stateNode;\n        var state = instance.state || null;\n\n        var props = workInProgress.pendingProps;\n        !props ? invariant(false, 'There must be pending props for an initial mount. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n        var unmaskedContext = getUnmaskedContext(workInProgress);\n\n        instance.props = props;\n        instance.state = workInProgress.memoizedState = state;\n        instance.refs = emptyObject;\n        instance.context = getMaskedContext(workInProgress, unmaskedContext);\n\n        if (enableAsyncSubtreeAPI && workInProgress.type != null && workInProgress.type.prototype != null && workInProgress.type.prototype.unstable_isAsyncReactComponent === true) {\n          workInProgress.internalContextTag |= AsyncUpdates;\n        }\n\n        if (typeof instance.componentWillMount === 'function') {\n          callComponentWillMount(workInProgress, instance);\n          // If we had additional state updates during this life-cycle, let's\n          // process them now.\n          var updateQueue = workInProgress.updateQueue;\n          if (updateQueue !== null) {\n            instance.state = processUpdateQueue(current, workInProgress, updateQueue, instance, props, renderExpirationTime);\n          }\n        }\n        if (typeof instance.componentDidMount === 'function') {\n          workInProgress.effectTag |= Update;\n        }\n      }\n\n      // Called on a preexisting class instance. Returns false if a resumed render\n      // could be reused.\n      // function resumeMountClassInstance(\n      //   workInProgress: Fiber,\n      //   priorityLevel: PriorityLevel,\n      // ): boolean {\n      //   const instance = workInProgress.stateNode;\n      //   resetInputPointers(workInProgress, instance);\n\n      //   let newState = workInProgress.memoizedState;\n      //   let newProps = workInProgress.pendingProps;\n      //   if (!newProps) {\n      //     // If there isn't any new props, then we'll reuse the memoized props.\n      //     // This could be from already completed work.\n      //     newProps = workInProgress.memoizedProps;\n      //     invariant(\n      //       newProps != null,\n      //       'There should always be pending or memoized props. This error is ' +\n      //         'likely caused by a bug in React. Please file an issue.',\n      //     );\n      //   }\n      //   const newUnmaskedContext = getUnmaskedContext(workInProgress);\n      //   const newContext = getMaskedContext(workInProgress, newUnmaskedContext);\n\n      //   const oldContext = instance.context;\n      //   const oldProps = workInProgress.memoizedProps;\n\n      //   if (\n      //     typeof instance.componentWillReceiveProps === 'function' &&\n      //     (oldProps !== newProps || oldContext !== newContext)\n      //   ) {\n      //     callComponentWillReceiveProps(\n      //       workInProgress,\n      //       instance,\n      //       newProps,\n      //       newContext,\n      //     );\n      //   }\n\n      //   // Process the update queue before calling shouldComponentUpdate\n      //   const updateQueue = workInProgress.updateQueue;\n      //   if (updateQueue !== null) {\n      //     newState = processUpdateQueue(\n      //       workInProgress,\n      //       updateQueue,\n      //       instance,\n      //       newState,\n      //       newProps,\n      //       priorityLevel,\n      //     );\n      //   }\n\n      //   // TODO: Should we deal with a setState that happened after the last\n      //   // componentWillMount and before this componentWillMount? Probably\n      //   // unsupported anyway.\n\n      //   if (\n      //     !checkShouldComponentUpdate(\n      //       workInProgress,\n      //       workInProgress.memoizedProps,\n      //       newProps,\n      //       workInProgress.memoizedState,\n      //       newState,\n      //       newContext,\n      //     )\n      //   ) {\n      //     // Update the existing instance's state, props, and context pointers even\n      //     // though we're bailing out.\n      //     instance.props = newProps;\n      //     instance.state = newState;\n      //     instance.context = newContext;\n      //     return false;\n      //   }\n\n      //   // Update the input pointers now so that they are correct when we call\n      //   // componentWillMount\n      //   instance.props = newProps;\n      //   instance.state = newState;\n      //   instance.context = newContext;\n\n      //   if (typeof instance.componentWillMount === 'function') {\n      //     callComponentWillMount(workInProgress, instance);\n      //     // componentWillMount may have called setState. Process the update queue.\n      //     const newUpdateQueue = workInProgress.updateQueue;\n      //     if (newUpdateQueue !== null) {\n      //       newState = processUpdateQueue(\n      //         workInProgress,\n      //         newUpdateQueue,\n      //         instance,\n      //         newState,\n      //         newProps,\n      //         priorityLevel,\n      //       );\n      //     }\n      //   }\n\n      //   if (typeof instance.componentDidMount === 'function') {\n      //     workInProgress.effectTag |= Update;\n      //   }\n\n      //   instance.state = newState;\n\n      //   return true;\n      // }\n\n      // Invokes the update life-cycles and returns false if it shouldn't rerender.\n      function updateClassInstance(current, workInProgress, renderExpirationTime) {\n        var instance = workInProgress.stateNode;\n        resetInputPointers(workInProgress, instance);\n\n        var oldProps = workInProgress.memoizedProps;\n        var newProps = workInProgress.pendingProps;\n        if (!newProps) {\n          // If there aren't any new props, then we'll reuse the memoized props.\n          // This could be from already completed work.\n          newProps = oldProps;\n          !(newProps != null) ? invariant(false, 'There should always be pending or memoized props. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        }\n        var oldContext = instance.context;\n        var newUnmaskedContext = getUnmaskedContext(workInProgress);\n        var newContext = getMaskedContext(workInProgress, newUnmaskedContext);\n\n        // Note: During these life-cycles, instance.props/instance.state are what\n        // ever the previously attempted to render - not the \"current\". However,\n        // during componentDidUpdate we pass the \"current\" props.\n\n        if (typeof instance.componentWillReceiveProps === 'function' && (oldProps !== newProps || oldContext !== newContext)) {\n          callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);\n        }\n\n        // Compute the next state using the memoized state and the update queue.\n        var oldState = workInProgress.memoizedState;\n        // TODO: Previous state can be null.\n        var newState = void 0;\n        if (workInProgress.updateQueue !== null) {\n          newState = processUpdateQueue(current, workInProgress, workInProgress.updateQueue, instance, newProps, renderExpirationTime);\n        } else {\n          newState = oldState;\n        }\n\n        if (oldProps === newProps && oldState === newState && !hasContextChanged() && !(workInProgress.updateQueue !== null && workInProgress.updateQueue.hasForceUpdate)) {\n          // If an update was already in progress, we should schedule an Update\n          // effect even though we're bailing out, so that cWU/cDU are called.\n          if (typeof instance.componentDidUpdate === 'function') {\n            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n              workInProgress.effectTag |= Update;\n            }\n          }\n          return false;\n        }\n\n        var shouldUpdate = checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);\n\n        if (shouldUpdate) {\n          if (typeof instance.componentWillUpdate === 'function') {\n            startPhaseTimer(workInProgress, 'componentWillUpdate');\n            instance.componentWillUpdate(newProps, newState, newContext);\n            stopPhaseTimer();\n\n            // Simulate an async bailout/interruption by invoking lifecycle twice.\n            if (debugRenderPhaseSideEffects) {\n              instance.componentWillUpdate(newProps, newState, newContext);\n            }\n          }\n          if (typeof instance.componentDidUpdate === 'function') {\n            workInProgress.effectTag |= Update;\n          }\n        } else {\n          // If an update was already in progress, we should schedule an Update\n          // effect even though we're bailing out, so that cWU/cDU are called.\n          if (typeof instance.componentDidUpdate === 'function') {\n            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {\n              workInProgress.effectTag |= Update;\n            }\n          }\n\n          // If shouldComponentUpdate returned false, we should still update the\n          // memoized props/state to indicate that this work can be reused.\n          memoizeProps(workInProgress, newProps);\n          memoizeState(workInProgress, newState);\n        }\n\n        // Update the existing instance's state, props, and context pointers even\n        // if shouldComponentUpdate returns false.\n        instance.props = newProps;\n        instance.state = newState;\n        instance.context = newContext;\n\n        return shouldUpdate;\n      }\n\n      return {\n        adoptClassInstance: adoptClassInstance,\n        constructClassInstance: constructClassInstance,\n        mountClassInstance: mountClassInstance,\n        // resumeMountClassInstance,\n        updateClassInstance: updateClassInstance\n      };\n    };\n\n    // The Symbol used to tag the ReactElement-like types. If there is no native Symbol\n    // nor polyfill, then a plain number is used for performance.\n    var hasSymbol = typeof Symbol === 'function' && Symbol['for'];\n\n    var REACT_ELEMENT_TYPE = hasSymbol ? Symbol['for']('react.element') : 0xeac7;\n    var REACT_CALL_TYPE = hasSymbol ? Symbol['for']('react.call') : 0xeac8;\n    var REACT_RETURN_TYPE = hasSymbol ? Symbol['for']('react.return') : 0xeac9;\n    var REACT_PORTAL_TYPE = hasSymbol ? Symbol['for']('react.portal') : 0xeaca;\n    var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol['for']('react.fragment') : 0xeacb;\n\n    var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;\n    var FAUX_ITERATOR_SYMBOL = '@@iterator';\n\n    function getIteratorFn(maybeIterable) {\n      if (maybeIterable === null || typeof maybeIterable === 'undefined') {\n        return null;\n      }\n      var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];\n      if (typeof maybeIterator === 'function') {\n        return maybeIterator;\n      }\n      return null;\n    }\n\n    var getCurrentFiberStackAddendum$1 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    {\n      var didWarnAboutMaps = false;\n      /**\n       * Warn if there's no key explicitly set on dynamic arrays of children or\n       * object keys are not valid. This allows us to keep track of children between\n       * updates.\n       */\n      var ownerHasKeyUseWarning = {};\n      var ownerHasFunctionTypeWarning = {};\n\n      var warnForMissingKey = function (child) {\n        if (child === null || typeof child !== 'object') {\n          return;\n        }\n        if (!child._store || child._store.validated || child.key != null) {\n          return;\n        }\n        !(typeof child._store === 'object') ? invariant(false, 'React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        child._store.validated = true;\n\n        var currentComponentErrorInfo = 'Each child in an array or iterator should have a unique ' + '\"key\" prop. See https://fb.me/react-warning-keys for ' + 'more information.' + (getCurrentFiberStackAddendum$1() || '');\n        if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {\n          return;\n        }\n        ownerHasKeyUseWarning[currentComponentErrorInfo] = true;\n\n        warning(false, 'Each child in an array or iterator should have a unique ' + '\"key\" prop. See https://fb.me/react-warning-keys for ' + 'more information.%s', getCurrentFiberStackAddendum$1());\n      };\n    }\n\n    var isArray$1 = Array.isArray;\n\n    function coerceRef(current, element) {\n      var mixedRef = element.ref;\n      if (mixedRef !== null && typeof mixedRef !== 'function') {\n        if (element._owner) {\n          var owner = element._owner;\n          var inst = void 0;\n          if (owner) {\n            var ownerFiber = owner;\n            !(ownerFiber.tag === ClassComponent) ? invariant(false, 'Stateless function components cannot have refs.') : void 0;\n            inst = ownerFiber.stateNode;\n          }\n          !inst ? invariant(false, 'Missing owner for string ref %s. This error is likely caused by a bug in React. Please file an issue.', mixedRef) : void 0;\n          var stringRef = '' + mixedRef;\n          // Check if previous string ref matches new string ref\n          if (current !== null && current.ref !== null && current.ref._stringRef === stringRef) {\n            return current.ref;\n          }\n          var ref = function (value) {\n            var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;\n            if (value === null) {\n              delete refs[stringRef];\n            } else {\n              refs[stringRef] = value;\n            }\n          };\n          ref._stringRef = stringRef;\n          return ref;\n        } else {\n          !(typeof mixedRef === 'string') ? invariant(false, 'Expected ref to be a function or a string.') : void 0;\n          !element._owner ? invariant(false, 'Element ref was specified as a string (%s) but no owner was set. You may have multiple copies of React loaded. (details: https://fb.me/react-refs-must-have-owner).', mixedRef) : void 0;\n        }\n      }\n      return mixedRef;\n    }\n\n    function throwOnInvalidObjectType(returnFiber, newChild) {\n      if (returnFiber.type !== 'textarea') {\n        var addendum = '';\n        {\n          addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + (getCurrentFiberStackAddendum$1() || '');\n        }\n        invariant(false, 'Objects are not valid as a React child (found: %s).%s', Object.prototype.toString.call(newChild) === '[object Object]' ? 'object with keys {' + Object.keys(newChild).join(', ') + '}' : newChild, addendum);\n      }\n    }\n\n    function warnOnFunctionType() {\n      var currentComponentErrorInfo = 'Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of <Component /> from render. ' + 'Or maybe you meant to call this function rather than return it.' + (getCurrentFiberStackAddendum$1() || '');\n\n      if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {\n        return;\n      }\n      ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;\n\n      warning(false, 'Functions are not valid as a React child. This may happen if ' + 'you return a Component instead of <Component /> from render. ' + 'Or maybe you meant to call this function rather than return it.%s', getCurrentFiberStackAddendum$1() || '');\n    }\n\n    // This wrapper function exists because I expect to clone the code in each path\n    // to be able to optimize each path individually by branching early. This needs\n    // a compiler or we can do it manually. Helpers that don't need this branching\n    // live outside of this function.\n    function ChildReconciler(shouldTrackSideEffects) {\n      function deleteChild(returnFiber, childToDelete) {\n        if (!shouldTrackSideEffects) {\n          // Noop.\n          return;\n        }\n        // Deletions are added in reversed order so we add it to the front.\n        // At this point, the return fiber's effect list is empty except for\n        // deletions, so we can just append the deletion to the list. The remaining\n        // effects aren't added until the complete phase. Once we implement\n        // resuming, this may not be true.\n        var last = returnFiber.lastEffect;\n        if (last !== null) {\n          last.nextEffect = childToDelete;\n          returnFiber.lastEffect = childToDelete;\n        } else {\n          returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;\n        }\n        childToDelete.nextEffect = null;\n        childToDelete.effectTag = Deletion;\n      }\n\n      function deleteRemainingChildren(returnFiber, currentFirstChild) {\n        if (!shouldTrackSideEffects) {\n          // Noop.\n          return null;\n        }\n\n        // TODO: For the shouldClone case, this could be micro-optimized a bit by\n        // assuming that after the first child we've already added everything.\n        var childToDelete = currentFirstChild;\n        while (childToDelete !== null) {\n          deleteChild(returnFiber, childToDelete);\n          childToDelete = childToDelete.sibling;\n        }\n        return null;\n      }\n\n      function mapRemainingChildren(returnFiber, currentFirstChild) {\n        // Add the remaining children to a temporary map so that we can find them by\n        // keys quickly. Implicit (null) keys get added to this set with their index\n        var existingChildren = new Map();\n\n        var existingChild = currentFirstChild;\n        while (existingChild !== null) {\n          if (existingChild.key !== null) {\n            existingChildren.set(existingChild.key, existingChild);\n          } else {\n            existingChildren.set(existingChild.index, existingChild);\n          }\n          existingChild = existingChild.sibling;\n        }\n        return existingChildren;\n      }\n\n      function useFiber(fiber, pendingProps, expirationTime) {\n        // We currently set sibling to null and index to 0 here because it is easy\n        // to forget to do before returning it. E.g. for the single child case.\n        var clone = createWorkInProgress(fiber, pendingProps, expirationTime);\n        clone.index = 0;\n        clone.sibling = null;\n        return clone;\n      }\n\n      function placeChild(newFiber, lastPlacedIndex, newIndex) {\n        newFiber.index = newIndex;\n        if (!shouldTrackSideEffects) {\n          // Noop.\n          return lastPlacedIndex;\n        }\n        var current = newFiber.alternate;\n        if (current !== null) {\n          var oldIndex = current.index;\n          if (oldIndex < lastPlacedIndex) {\n            // This is a move.\n            newFiber.effectTag = Placement;\n            return lastPlacedIndex;\n          } else {\n            // This item can stay in place.\n            return oldIndex;\n          }\n        } else {\n          // This is an insertion.\n          newFiber.effectTag = Placement;\n          return lastPlacedIndex;\n        }\n      }\n\n      function placeSingleChild(newFiber) {\n        // This is simpler for the single child case. We only need to do a\n        // placement for inserting new children.\n        if (shouldTrackSideEffects && newFiber.alternate === null) {\n          newFiber.effectTag = Placement;\n        }\n        return newFiber;\n      }\n\n      function updateTextNode(returnFiber, current, textContent, expirationTime) {\n        if (current === null || current.tag !== HostText) {\n          // Insert\n          var created = createFiberFromText(textContent, returnFiber.internalContextTag, expirationTime);\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          // Update\n          var existing = useFiber(current, textContent, expirationTime);\n          existing['return'] = returnFiber;\n          return existing;\n        }\n      }\n\n      function updateElement(returnFiber, current, element, expirationTime) {\n        if (current !== null && current.type === element.type) {\n          // Move based on index\n          var existing = useFiber(current, element.props, expirationTime);\n          existing.ref = coerceRef(current, element);\n          existing['return'] = returnFiber;\n          {\n            existing._debugSource = element._source;\n            existing._debugOwner = element._owner;\n          }\n          return existing;\n        } else {\n          // Insert\n          var created = createFiberFromElement(element, returnFiber.internalContextTag, expirationTime);\n          created.ref = coerceRef(current, element);\n          created['return'] = returnFiber;\n          return created;\n        }\n      }\n\n      function updateCall(returnFiber, current, call, expirationTime) {\n        // TODO: Should this also compare handler to determine whether to reuse?\n        if (current === null || current.tag !== CallComponent) {\n          // Insert\n          var created = createFiberFromCall(call, returnFiber.internalContextTag, expirationTime);\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          // Move based on index\n          var existing = useFiber(current, call, expirationTime);\n          existing['return'] = returnFiber;\n          return existing;\n        }\n      }\n\n      function updateReturn(returnFiber, current, returnNode, expirationTime) {\n        if (current === null || current.tag !== ReturnComponent) {\n          // Insert\n          var created = createFiberFromReturn(returnNode, returnFiber.internalContextTag, expirationTime);\n          created.type = returnNode.value;\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          // Move based on index\n          var existing = useFiber(current, null, expirationTime);\n          existing.type = returnNode.value;\n          existing['return'] = returnFiber;\n          return existing;\n        }\n      }\n\n      function updatePortal(returnFiber, current, portal, expirationTime) {\n        if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {\n          // Insert\n          var created = createFiberFromPortal(portal, returnFiber.internalContextTag, expirationTime);\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          // Update\n          var existing = useFiber(current, portal.children || [], expirationTime);\n          existing['return'] = returnFiber;\n          return existing;\n        }\n      }\n\n      function updateFragment(returnFiber, current, fragment, expirationTime, key) {\n        if (current === null || current.tag !== Fragment) {\n          // Insert\n          var created = createFiberFromFragment(fragment, returnFiber.internalContextTag, expirationTime, key);\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          // Update\n          var existing = useFiber(current, fragment, expirationTime);\n          existing['return'] = returnFiber;\n          return existing;\n        }\n      }\n\n      function createChild(returnFiber, newChild, expirationTime) {\n        if (typeof newChild === 'string' || typeof newChild === 'number') {\n          // Text nodes don't have keys. If the previous node is implicitly keyed\n          // we can continue to replace it without aborting even if it is not a text\n          // node.\n          var created = createFiberFromText('' + newChild, returnFiber.internalContextTag, expirationTime);\n          created['return'] = returnFiber;\n          return created;\n        }\n\n        if (typeof newChild === 'object' && newChild !== null) {\n          switch (newChild.$$typeof) {\n            case REACT_ELEMENT_TYPE:\n              {\n                if (newChild.type === REACT_FRAGMENT_TYPE) {\n                  var _created = createFiberFromFragment(newChild.props.children, returnFiber.internalContextTag, expirationTime, newChild.key);\n                  _created['return'] = returnFiber;\n                  return _created;\n                } else {\n                  var _created2 = createFiberFromElement(newChild, returnFiber.internalContextTag, expirationTime);\n                  _created2.ref = coerceRef(null, newChild);\n                  _created2['return'] = returnFiber;\n                  return _created2;\n                }\n              }\n\n            case REACT_CALL_TYPE:\n              {\n                var _created3 = createFiberFromCall(newChild, returnFiber.internalContextTag, expirationTime);\n                _created3['return'] = returnFiber;\n                return _created3;\n              }\n\n            case REACT_RETURN_TYPE:\n              {\n                var _created4 = createFiberFromReturn(newChild, returnFiber.internalContextTag, expirationTime);\n                _created4.type = newChild.value;\n                _created4['return'] = returnFiber;\n                return _created4;\n              }\n\n            case REACT_PORTAL_TYPE:\n              {\n                var _created5 = createFiberFromPortal(newChild, returnFiber.internalContextTag, expirationTime);\n                _created5['return'] = returnFiber;\n                return _created5;\n              }\n          }\n\n          if (isArray$1(newChild) || getIteratorFn(newChild)) {\n            var _created6 = createFiberFromFragment(newChild, returnFiber.internalContextTag, expirationTime, null);\n            _created6['return'] = returnFiber;\n            return _created6;\n          }\n\n          throwOnInvalidObjectType(returnFiber, newChild);\n        }\n\n        {\n          if (typeof newChild === 'function') {\n            warnOnFunctionType();\n          }\n        }\n\n        return null;\n      }\n\n      function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {\n        // Update the fiber if the keys match, otherwise return null.\n\n        var key = oldFiber !== null ? oldFiber.key : null;\n\n        if (typeof newChild === 'string' || typeof newChild === 'number') {\n          // Text nodes don't have keys. If the previous node is implicitly keyed\n          // we can continue to replace it without aborting even if it is not a text\n          // node.\n          if (key !== null) {\n            return null;\n          }\n          return updateTextNode(returnFiber, oldFiber, '' + newChild, expirationTime);\n        }\n\n        if (typeof newChild === 'object' && newChild !== null) {\n          switch (newChild.$$typeof) {\n            case REACT_ELEMENT_TYPE:\n              {\n                if (newChild.key === key) {\n                  if (newChild.type === REACT_FRAGMENT_TYPE) {\n                    return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);\n                  }\n                  return updateElement(returnFiber, oldFiber, newChild, expirationTime);\n                } else {\n                  return null;\n                }\n              }\n\n            case REACT_CALL_TYPE:\n              {\n                if (newChild.key === key) {\n                  return updateCall(returnFiber, oldFiber, newChild, expirationTime);\n                } else {\n                  return null;\n                }\n              }\n\n            case REACT_RETURN_TYPE:\n              {\n                // Returns don't have keys. If the previous node is implicitly keyed\n                // we can continue to replace it without aborting even if it is not a\n                // yield.\n                if (key === null) {\n                  return updateReturn(returnFiber, oldFiber, newChild, expirationTime);\n                } else {\n                  return null;\n                }\n              }\n\n            case REACT_PORTAL_TYPE:\n              {\n                if (newChild.key === key) {\n                  return updatePortal(returnFiber, oldFiber, newChild, expirationTime);\n                } else {\n                  return null;\n                }\n              }\n          }\n\n          if (isArray$1(newChild) || getIteratorFn(newChild)) {\n            if (key !== null) {\n              return null;\n            }\n\n            return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);\n          }\n\n          throwOnInvalidObjectType(returnFiber, newChild);\n        }\n\n        {\n          if (typeof newChild === 'function') {\n            warnOnFunctionType();\n          }\n        }\n\n        return null;\n      }\n\n      function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {\n        if (typeof newChild === 'string' || typeof newChild === 'number') {\n          // Text nodes don't have keys, so we neither have to check the old nor\n          // new node for the key. If both are text nodes, they match.\n          var matchedFiber = existingChildren.get(newIdx) || null;\n          return updateTextNode(returnFiber, matchedFiber, '' + newChild, expirationTime);\n        }\n\n        if (typeof newChild === 'object' && newChild !== null) {\n          switch (newChild.$$typeof) {\n            case REACT_ELEMENT_TYPE:\n              {\n                var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;\n                if (newChild.type === REACT_FRAGMENT_TYPE) {\n                  return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);\n                }\n                return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);\n              }\n\n            case REACT_CALL_TYPE:\n              {\n                var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;\n                return updateCall(returnFiber, _matchedFiber2, newChild, expirationTime);\n              }\n\n            case REACT_RETURN_TYPE:\n              {\n                // Returns don't have keys, so we neither have to check the old nor\n                // new node for the key. If both are returns, they match.\n                var _matchedFiber3 = existingChildren.get(newIdx) || null;\n                return updateReturn(returnFiber, _matchedFiber3, newChild, expirationTime);\n              }\n\n            case REACT_PORTAL_TYPE:\n              {\n                var _matchedFiber4 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;\n                return updatePortal(returnFiber, _matchedFiber4, newChild, expirationTime);\n              }\n          }\n\n          if (isArray$1(newChild) || getIteratorFn(newChild)) {\n            var _matchedFiber5 = existingChildren.get(newIdx) || null;\n            return updateFragment(returnFiber, _matchedFiber5, newChild, expirationTime, null);\n          }\n\n          throwOnInvalidObjectType(returnFiber, newChild);\n        }\n\n        {\n          if (typeof newChild === 'function') {\n            warnOnFunctionType();\n          }\n        }\n\n        return null;\n      }\n\n      /**\n       * Warns if there is a duplicate or missing key\n       */\n      function warnOnInvalidKey(child, knownKeys) {\n        {\n          if (typeof child !== 'object' || child === null) {\n            return knownKeys;\n          }\n          switch (child.$$typeof) {\n            case REACT_ELEMENT_TYPE:\n            case REACT_CALL_TYPE:\n            case REACT_PORTAL_TYPE:\n              warnForMissingKey(child);\n              var key = child.key;\n              if (typeof key !== 'string') {\n                break;\n              }\n              if (knownKeys === null) {\n                knownKeys = new Set();\n                knownKeys.add(key);\n                break;\n              }\n              if (!knownKeys.has(key)) {\n                knownKeys.add(key);\n                break;\n              }\n              warning(false, 'Encountered two children with the same key, `%s`. ' + 'Keys should be unique so that components maintain their identity ' + 'across updates. Non-unique keys may cause children to be ' + 'duplicated and/or omitted — the behavior is unsupported and ' + 'could change in a future version.%s', key, getCurrentFiberStackAddendum$1());\n              break;\n            default:\n              break;\n          }\n        }\n        return knownKeys;\n      }\n\n      function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {\n        // This algorithm can't optimize by searching from boths ends since we\n        // don't have backpointers on fibers. I'm trying to see how far we can get\n        // with that model. If it ends up not being worth the tradeoffs, we can\n        // add it later.\n\n        // Even with a two ended optimization, we'd want to optimize for the case\n        // where there are few changes and brute force the comparison instead of\n        // going for the Map. It'd like to explore hitting that path first in\n        // forward-only mode and only go for the Map once we notice that we need\n        // lots of look ahead. This doesn't handle reversal as well as two ended\n        // search but that's unusual. Besides, for the two ended optimization to\n        // work on Iterables, we'd need to copy the whole set.\n\n        // In this first iteration, we'll just live with hitting the bad case\n        // (adding everything to a Map) in for every insert/move.\n\n        // If you change this code, also update reconcileChildrenIterator() which\n        // uses the same algorithm.\n\n        {\n          // First, validate keys.\n          var knownKeys = null;\n          for (var i = 0; i < newChildren.length; i++) {\n            var child = newChildren[i];\n            knownKeys = warnOnInvalidKey(child, knownKeys);\n          }\n        }\n\n        var resultingFirstChild = null;\n        var previousNewFiber = null;\n\n        var oldFiber = currentFirstChild;\n        var lastPlacedIndex = 0;\n        var newIdx = 0;\n        var nextOldFiber = null;\n        for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {\n          if (oldFiber.index > newIdx) {\n            nextOldFiber = oldFiber;\n            oldFiber = null;\n          } else {\n            nextOldFiber = oldFiber.sibling;\n          }\n          var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);\n          if (newFiber === null) {\n            // TODO: This breaks on empty slots like null children. That's\n            // unfortunate because it triggers the slow path all the time. We need\n            // a better way to communicate whether this was a miss or null,\n            // boolean, undefined, etc.\n            if (oldFiber === null) {\n              oldFiber = nextOldFiber;\n            }\n            break;\n          }\n          if (shouldTrackSideEffects) {\n            if (oldFiber && newFiber.alternate === null) {\n              // We matched the slot, but we didn't reuse the existing fiber, so we\n              // need to delete the existing child.\n              deleteChild(returnFiber, oldFiber);\n            }\n          }\n          lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n          if (previousNewFiber === null) {\n            // TODO: Move out of the loop. This only happens for the first run.\n            resultingFirstChild = newFiber;\n          } else {\n            // TODO: Defer siblings if we're not at the right index for this slot.\n            // I.e. if we had null values before, then we want to defer this\n            // for each null value. However, we also don't want to call updateSlot\n            // with the previous one.\n            previousNewFiber.sibling = newFiber;\n          }\n          previousNewFiber = newFiber;\n          oldFiber = nextOldFiber;\n        }\n\n        if (newIdx === newChildren.length) {\n          // We've reached the end of the new children. We can delete the rest.\n          deleteRemainingChildren(returnFiber, oldFiber);\n          return resultingFirstChild;\n        }\n\n        if (oldFiber === null) {\n          // If we don't have any more existing children we can choose a fast path\n          // since the rest will all be insertions.\n          for (; newIdx < newChildren.length; newIdx++) {\n            var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);\n            if (!_newFiber) {\n              continue;\n            }\n            lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);\n            if (previousNewFiber === null) {\n              // TODO: Move out of the loop. This only happens for the first run.\n              resultingFirstChild = _newFiber;\n            } else {\n              previousNewFiber.sibling = _newFiber;\n            }\n            previousNewFiber = _newFiber;\n          }\n          return resultingFirstChild;\n        }\n\n        // Add all children to a key map for quick lookups.\n        var existingChildren = mapRemainingChildren(returnFiber, oldFiber);\n\n        // Keep scanning and use the map to restore deleted items as moves.\n        for (; newIdx < newChildren.length; newIdx++) {\n          var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], expirationTime);\n          if (_newFiber2) {\n            if (shouldTrackSideEffects) {\n              if (_newFiber2.alternate !== null) {\n                // The new fiber is a work in progress, but if there exists a\n                // current, that means that we reused the fiber. We need to delete\n                // it from the child list so that we don't add it to the deletion\n                // list.\n                existingChildren['delete'](_newFiber2.key === null ? newIdx : _newFiber2.key);\n              }\n            }\n            lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);\n            if (previousNewFiber === null) {\n              resultingFirstChild = _newFiber2;\n            } else {\n              previousNewFiber.sibling = _newFiber2;\n            }\n            previousNewFiber = _newFiber2;\n          }\n        }\n\n        if (shouldTrackSideEffects) {\n          // Any existing children that weren't consumed above were deleted. We need\n          // to add them to the deletion list.\n          existingChildren.forEach(function (child) {\n            return deleteChild(returnFiber, child);\n          });\n        }\n\n        return resultingFirstChild;\n      }\n\n      function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) {\n        // This is the same implementation as reconcileChildrenArray(),\n        // but using the iterator instead.\n\n        var iteratorFn = getIteratorFn(newChildrenIterable);\n        !(typeof iteratorFn === 'function') ? invariant(false, 'An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n        {\n          // Warn about using Maps as children\n          if (typeof newChildrenIterable.entries === 'function') {\n            var possibleMap = newChildrenIterable;\n            if (possibleMap.entries === iteratorFn) {\n              warning(didWarnAboutMaps, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', getCurrentFiberStackAddendum$1());\n              didWarnAboutMaps = true;\n            }\n          }\n\n          // First, validate keys.\n          // We'll get a different iterator later for the main pass.\n          var _newChildren = iteratorFn.call(newChildrenIterable);\n          if (_newChildren) {\n            var knownKeys = null;\n            var _step = _newChildren.next();\n            for (; !_step.done; _step = _newChildren.next()) {\n              var child = _step.value;\n              knownKeys = warnOnInvalidKey(child, knownKeys);\n            }\n          }\n        }\n\n        var newChildren = iteratorFn.call(newChildrenIterable);\n        !(newChildren != null) ? invariant(false, 'An iterable object provided no iterator.') : void 0;\n\n        var resultingFirstChild = null;\n        var previousNewFiber = null;\n\n        var oldFiber = currentFirstChild;\n        var lastPlacedIndex = 0;\n        var newIdx = 0;\n        var nextOldFiber = null;\n\n        var step = newChildren.next();\n        for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {\n          if (oldFiber.index > newIdx) {\n            nextOldFiber = oldFiber;\n            oldFiber = null;\n          } else {\n            nextOldFiber = oldFiber.sibling;\n          }\n          var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime);\n          if (newFiber === null) {\n            // TODO: This breaks on empty slots like null children. That's\n            // unfortunate because it triggers the slow path all the time. We need\n            // a better way to communicate whether this was a miss or null,\n            // boolean, undefined, etc.\n            if (!oldFiber) {\n              oldFiber = nextOldFiber;\n            }\n            break;\n          }\n          if (shouldTrackSideEffects) {\n            if (oldFiber && newFiber.alternate === null) {\n              // We matched the slot, but we didn't reuse the existing fiber, so we\n              // need to delete the existing child.\n              deleteChild(returnFiber, oldFiber);\n            }\n          }\n          lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);\n          if (previousNewFiber === null) {\n            // TODO: Move out of the loop. This only happens for the first run.\n            resultingFirstChild = newFiber;\n          } else {\n            // TODO: Defer siblings if we're not at the right index for this slot.\n            // I.e. if we had null values before, then we want to defer this\n            // for each null value. However, we also don't want to call updateSlot\n            // with the previous one.\n            previousNewFiber.sibling = newFiber;\n          }\n          previousNewFiber = newFiber;\n          oldFiber = nextOldFiber;\n        }\n\n        if (step.done) {\n          // We've reached the end of the new children. We can delete the rest.\n          deleteRemainingChildren(returnFiber, oldFiber);\n          return resultingFirstChild;\n        }\n\n        if (oldFiber === null) {\n          // If we don't have any more existing children we can choose a fast path\n          // since the rest will all be insertions.\n          for (; !step.done; newIdx++, step = newChildren.next()) {\n            var _newFiber3 = createChild(returnFiber, step.value, expirationTime);\n            if (_newFiber3 === null) {\n              continue;\n            }\n            lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);\n            if (previousNewFiber === null) {\n              // TODO: Move out of the loop. This only happens for the first run.\n              resultingFirstChild = _newFiber3;\n            } else {\n              previousNewFiber.sibling = _newFiber3;\n            }\n            previousNewFiber = _newFiber3;\n          }\n          return resultingFirstChild;\n        }\n\n        // Add all children to a key map for quick lookups.\n        var existingChildren = mapRemainingChildren(returnFiber, oldFiber);\n\n        // Keep scanning and use the map to restore deleted items as moves.\n        for (; !step.done; newIdx++, step = newChildren.next()) {\n          var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, expirationTime);\n          if (_newFiber4 !== null) {\n            if (shouldTrackSideEffects) {\n              if (_newFiber4.alternate !== null) {\n                // The new fiber is a work in progress, but if there exists a\n                // current, that means that we reused the fiber. We need to delete\n                // it from the child list so that we don't add it to the deletion\n                // list.\n                existingChildren['delete'](_newFiber4.key === null ? newIdx : _newFiber4.key);\n              }\n            }\n            lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);\n            if (previousNewFiber === null) {\n              resultingFirstChild = _newFiber4;\n            } else {\n              previousNewFiber.sibling = _newFiber4;\n            }\n            previousNewFiber = _newFiber4;\n          }\n        }\n\n        if (shouldTrackSideEffects) {\n          // Any existing children that weren't consumed above were deleted. We need\n          // to add them to the deletion list.\n          existingChildren.forEach(function (child) {\n            return deleteChild(returnFiber, child);\n          });\n        }\n\n        return resultingFirstChild;\n      }\n\n      function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, expirationTime) {\n        // There's no need to check for keys on text nodes since we don't have a\n        // way to define them.\n        if (currentFirstChild !== null && currentFirstChild.tag === HostText) {\n          // We already have an existing node so let's just update it and delete\n          // the rest.\n          deleteRemainingChildren(returnFiber, currentFirstChild.sibling);\n          var existing = useFiber(currentFirstChild, textContent, expirationTime);\n          existing['return'] = returnFiber;\n          return existing;\n        }\n        // The existing first child is not a text node so we need to create one\n        // and delete the existing ones.\n        deleteRemainingChildren(returnFiber, currentFirstChild);\n        var created = createFiberFromText(textContent, returnFiber.internalContextTag, expirationTime);\n        created['return'] = returnFiber;\n        return created;\n      }\n\n      function reconcileSingleElement(returnFiber, currentFirstChild, element, expirationTime) {\n        var key = element.key;\n        var child = currentFirstChild;\n        while (child !== null) {\n          // TODO: If key === null and child.key === null, then this only applies to\n          // the first item in the list.\n          if (child.key === key) {\n            if (child.tag === Fragment ? element.type === REACT_FRAGMENT_TYPE : child.type === element.type) {\n              deleteRemainingChildren(returnFiber, child.sibling);\n              var existing = useFiber(child, element.type === REACT_FRAGMENT_TYPE ? element.props.children : element.props, expirationTime);\n              existing.ref = coerceRef(child, element);\n              existing['return'] = returnFiber;\n              {\n                existing._debugSource = element._source;\n                existing._debugOwner = element._owner;\n              }\n              return existing;\n            } else {\n              deleteRemainingChildren(returnFiber, child);\n              break;\n            }\n          } else {\n            deleteChild(returnFiber, child);\n          }\n          child = child.sibling;\n        }\n\n        if (element.type === REACT_FRAGMENT_TYPE) {\n          var created = createFiberFromFragment(element.props.children, returnFiber.internalContextTag, expirationTime, element.key);\n          created['return'] = returnFiber;\n          return created;\n        } else {\n          var _created7 = createFiberFromElement(element, returnFiber.internalContextTag, expirationTime);\n          _created7.ref = coerceRef(currentFirstChild, element);\n          _created7['return'] = returnFiber;\n          return _created7;\n        }\n      }\n\n      function reconcileSingleCall(returnFiber, currentFirstChild, call, expirationTime) {\n        var key = call.key;\n        var child = currentFirstChild;\n        while (child !== null) {\n          // TODO: If key === null and child.key === null, then this only applies to\n          // the first item in the list.\n          if (child.key === key) {\n            if (child.tag === CallComponent) {\n              deleteRemainingChildren(returnFiber, child.sibling);\n              var existing = useFiber(child, call, expirationTime);\n              existing['return'] = returnFiber;\n              return existing;\n            } else {\n              deleteRemainingChildren(returnFiber, child);\n              break;\n            }\n          } else {\n            deleteChild(returnFiber, child);\n          }\n          child = child.sibling;\n        }\n\n        var created = createFiberFromCall(call, returnFiber.internalContextTag, expirationTime);\n        created['return'] = returnFiber;\n        return created;\n      }\n\n      function reconcileSingleReturn(returnFiber, currentFirstChild, returnNode, expirationTime) {\n        // There's no need to check for keys on yields since they're stateless.\n        var child = currentFirstChild;\n        if (child !== null) {\n          if (child.tag === ReturnComponent) {\n            deleteRemainingChildren(returnFiber, child.sibling);\n            var existing = useFiber(child, null, expirationTime);\n            existing.type = returnNode.value;\n            existing['return'] = returnFiber;\n            return existing;\n          } else {\n            deleteRemainingChildren(returnFiber, child);\n          }\n        }\n\n        var created = createFiberFromReturn(returnNode, returnFiber.internalContextTag, expirationTime);\n        created.type = returnNode.value;\n        created['return'] = returnFiber;\n        return created;\n      }\n\n      function reconcileSinglePortal(returnFiber, currentFirstChild, portal, expirationTime) {\n        var key = portal.key;\n        var child = currentFirstChild;\n        while (child !== null) {\n          // TODO: If key === null and child.key === null, then this only applies to\n          // the first item in the list.\n          if (child.key === key) {\n            if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {\n              deleteRemainingChildren(returnFiber, child.sibling);\n              var existing = useFiber(child, portal.children || [], expirationTime);\n              existing['return'] = returnFiber;\n              return existing;\n            } else {\n              deleteRemainingChildren(returnFiber, child);\n              break;\n            }\n          } else {\n            deleteChild(returnFiber, child);\n          }\n          child = child.sibling;\n        }\n\n        var created = createFiberFromPortal(portal, returnFiber.internalContextTag, expirationTime);\n        created['return'] = returnFiber;\n        return created;\n      }\n\n      // This API will tag the children with the side-effect of the reconciliation\n      // itself. They will be added to the side-effect list as we pass through the\n      // children and the parent.\n      function reconcileChildFibers(returnFiber, currentFirstChild, newChild, expirationTime) {\n        // This function is not recursive.\n        // If the top level item is an array, we treat it as a set of children,\n        // not as a fragment. Nested arrays on the other hand will be treated as\n        // fragment nodes. Recursion happens at the normal flow.\n\n        // Handle top level unkeyed fragments as if they were arrays.\n        // This leads to an ambiguity between <>{[...]}</> and <>...</>.\n        // We treat the ambiguous cases above the same.\n        if (typeof newChild === 'object' && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null) {\n          newChild = newChild.props.children;\n        }\n\n        // Handle object types\n        var isObject = typeof newChild === 'object' && newChild !== null;\n\n        if (isObject) {\n          switch (newChild.$$typeof) {\n            case REACT_ELEMENT_TYPE:\n              return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, expirationTime));\n\n            case REACT_CALL_TYPE:\n              return placeSingleChild(reconcileSingleCall(returnFiber, currentFirstChild, newChild, expirationTime));\n            case REACT_RETURN_TYPE:\n              return placeSingleChild(reconcileSingleReturn(returnFiber, currentFirstChild, newChild, expirationTime));\n            case REACT_PORTAL_TYPE:\n              return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, expirationTime));\n          }\n        }\n\n        if (typeof newChild === 'string' || typeof newChild === 'number') {\n          return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, '' + newChild, expirationTime));\n        }\n\n        if (isArray$1(newChild)) {\n          return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);\n        }\n\n        if (getIteratorFn(newChild)) {\n          return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);\n        }\n\n        if (isObject) {\n          throwOnInvalidObjectType(returnFiber, newChild);\n        }\n\n        {\n          if (typeof newChild === 'function') {\n            warnOnFunctionType();\n          }\n        }\n        if (typeof newChild === 'undefined') {\n          // If the new child is undefined, and the return fiber is a composite\n          // component, throw an error. If Fiber return types are disabled,\n          // we already threw above.\n          switch (returnFiber.tag) {\n            case ClassComponent:\n              {\n                {\n                  var instance = returnFiber.stateNode;\n                  if (instance.render._isMockFunction) {\n                    // We allow auto-mocks to proceed as if they're returning null.\n                    break;\n                  }\n                }\n              }\n            // Intentionally fall through to the next case, which handles both\n            // functions and classes\n            // eslint-disable-next-lined no-fallthrough\n            case FunctionalComponent:\n              {\n                var Component = returnFiber.type;\n                invariant(false, '%s(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.', Component.displayName || Component.name || 'Component');\n              }\n          }\n        }\n\n        // Remaining cases are all treated as empty.\n        return deleteRemainingChildren(returnFiber, currentFirstChild);\n      }\n\n      return reconcileChildFibers;\n    }\n\n    var reconcileChildFibers = ChildReconciler(true);\n    var mountChildFibers = ChildReconciler(false);\n\n    function cloneChildFibers(current, workInProgress) {\n      !(current === null || workInProgress.child === current.child) ? invariant(false, 'Resuming work not yet implemented.') : void 0;\n\n      if (workInProgress.child === null) {\n        return;\n      }\n\n      var currentChild = workInProgress.child;\n      var newChild = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);\n      workInProgress.child = newChild;\n\n      newChild['return'] = workInProgress;\n      while (currentChild.sibling !== null) {\n        currentChild = currentChild.sibling;\n        newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);\n        newChild['return'] = workInProgress;\n      }\n      newChild.sibling = null;\n    }\n\n    {\n      var warnedAboutStatelessRefs = {};\n    }\n\n    var ReactFiberBeginWork = function (config, hostContext, hydrationContext, scheduleWork, computeExpirationForFiber) {\n      var shouldSetTextContent = config.shouldSetTextContent,\n          useSyncScheduling = config.useSyncScheduling,\n          shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree;\n      var pushHostContext = hostContext.pushHostContext,\n          pushHostContainer = hostContext.pushHostContainer;\n      var enterHydrationState = hydrationContext.enterHydrationState,\n          resetHydrationState = hydrationContext.resetHydrationState,\n          tryToClaimNextHydratableInstance = hydrationContext.tryToClaimNextHydratableInstance;\n\n      var _ReactFiberClassCompo = ReactFiberClassComponent(scheduleWork, computeExpirationForFiber, memoizeProps, memoizeState),\n          adoptClassInstance = _ReactFiberClassCompo.adoptClassInstance,\n          constructClassInstance = _ReactFiberClassCompo.constructClassInstance,\n          mountClassInstance = _ReactFiberClassCompo.mountClassInstance,\n          updateClassInstance = _ReactFiberClassCompo.updateClassInstance;\n\n      // TODO: Remove this and use reconcileChildrenAtExpirationTime directly.\n\n\n      function reconcileChildren(current, workInProgress, nextChildren) {\n        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime);\n      }\n\n      function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) {\n        if (current === null) {\n          // If this is a fresh new component that hasn't been rendered yet, we\n          // won't update its child set by applying minimal side-effects. Instead,\n          // we will add them all to the child before it gets rendered. That means\n          // we can optimize this reconciliation pass by not tracking side-effects.\n          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);\n        } else {\n          // If the current child is the same as the work in progress, it means that\n          // we haven't yet started any work on these children. Therefore, we use\n          // the clone algorithm to create a copy of all the current children.\n\n          // If we had any progressed work already, that is invalid at this point so\n          // let's throw it out.\n          workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime);\n        }\n      }\n\n      function updateFragment(current, workInProgress) {\n        var nextChildren = workInProgress.pendingProps;\n        if (hasContextChanged()) {\n          // Normally we can bail out on props equality but if context has changed\n          // we don't do the bailout and we have to reuse existing props instead.\n          if (nextChildren === null) {\n            nextChildren = workInProgress.memoizedProps;\n          }\n        } else if (nextChildren === null || workInProgress.memoizedProps === nextChildren) {\n          return bailoutOnAlreadyFinishedWork(current, workInProgress);\n        }\n        reconcileChildren(current, workInProgress, nextChildren);\n        memoizeProps(workInProgress, nextChildren);\n        return workInProgress.child;\n      }\n\n      function markRef(current, workInProgress) {\n        var ref = workInProgress.ref;\n        if (ref !== null && (!current || current.ref !== ref)) {\n          // Schedule a Ref effect\n          workInProgress.effectTag |= Ref;\n        }\n      }\n\n      function updateFunctionalComponent(current, workInProgress) {\n        var fn = workInProgress.type;\n        var nextProps = workInProgress.pendingProps;\n\n        var memoizedProps = workInProgress.memoizedProps;\n        if (hasContextChanged()) {\n          // Normally we can bail out on props equality but if context has changed\n          // we don't do the bailout and we have to reuse existing props instead.\n          if (nextProps === null) {\n            nextProps = memoizedProps;\n          }\n        } else {\n          if (nextProps === null || memoizedProps === nextProps) {\n            return bailoutOnAlreadyFinishedWork(current, workInProgress);\n          }\n          // TODO: consider bringing fn.shouldComponentUpdate() back.\n          // It used to be here.\n        }\n\n        var unmaskedContext = getUnmaskedContext(workInProgress);\n        var context = getMaskedContext(workInProgress, unmaskedContext);\n\n        var nextChildren;\n\n        {\n          ReactCurrentOwner.current = workInProgress;\n          ReactDebugCurrentFiber.setCurrentPhase('render');\n          nextChildren = fn(nextProps, context);\n          ReactDebugCurrentFiber.setCurrentPhase(null);\n        }\n        // React DevTools reads this flag.\n        workInProgress.effectTag |= PerformedWork;\n        reconcileChildren(current, workInProgress, nextChildren);\n        memoizeProps(workInProgress, nextProps);\n        return workInProgress.child;\n      }\n\n      function updateClassComponent(current, workInProgress, renderExpirationTime) {\n        // Push context providers early to prevent context stack mismatches.\n        // During mounting we don't know the child context yet as the instance doesn't exist.\n        // We will invalidate the child context in finishClassComponent() right after rendering.\n        var hasContext = pushContextProvider(workInProgress);\n\n        var shouldUpdate = void 0;\n        if (current === null) {\n          if (!workInProgress.stateNode) {\n            // In the initial pass we might need to construct the instance.\n            constructClassInstance(workInProgress, workInProgress.pendingProps);\n            mountClassInstance(workInProgress, renderExpirationTime);\n            shouldUpdate = true;\n          } else {\n            invariant(false, 'Resuming work not yet implemented.');\n            // In a resume, we'll already have an instance we can reuse.\n            // shouldUpdate = resumeMountClassInstance(workInProgress, renderExpirationTime);\n          }\n        } else {\n          shouldUpdate = updateClassInstance(current, workInProgress, renderExpirationTime);\n        }\n        return finishClassComponent(current, workInProgress, shouldUpdate, hasContext);\n      }\n\n      function finishClassComponent(current, workInProgress, shouldUpdate, hasContext) {\n        // Refs should update even if shouldComponentUpdate returns false\n        markRef(current, workInProgress);\n\n        if (!shouldUpdate) {\n          // Context providers should defer to sCU for rendering\n          if (hasContext) {\n            invalidateContextProvider(workInProgress, false);\n          }\n\n          return bailoutOnAlreadyFinishedWork(current, workInProgress);\n        }\n\n        var instance = workInProgress.stateNode;\n\n        // Rerender\n        ReactCurrentOwner.current = workInProgress;\n        var nextChildren = void 0;\n        {\n          ReactDebugCurrentFiber.setCurrentPhase('render');\n          nextChildren = instance.render();\n          if (debugRenderPhaseSideEffects) {\n            instance.render();\n          }\n          ReactDebugCurrentFiber.setCurrentPhase(null);\n        }\n        // React DevTools reads this flag.\n        workInProgress.effectTag |= PerformedWork;\n        reconcileChildren(current, workInProgress, nextChildren);\n        // Memoize props and state using the values we just used to render.\n        // TODO: Restructure so we never read values from the instance.\n        memoizeState(workInProgress, instance.state);\n        memoizeProps(workInProgress, instance.props);\n\n        // The context might have changed so we need to recalculate it.\n        if (hasContext) {\n          invalidateContextProvider(workInProgress, true);\n        }\n\n        return workInProgress.child;\n      }\n\n      function pushHostRootContext(workInProgress) {\n        var root = workInProgress.stateNode;\n        if (root.pendingContext) {\n          pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);\n        } else if (root.context) {\n          // Should always be set\n          pushTopLevelContextObject(workInProgress, root.context, false);\n        }\n        pushHostContainer(workInProgress, root.containerInfo);\n      }\n\n      function updateHostRoot(current, workInProgress, renderExpirationTime) {\n        pushHostRootContext(workInProgress);\n        var updateQueue = workInProgress.updateQueue;\n        if (updateQueue !== null) {\n          var prevState = workInProgress.memoizedState;\n          var state = processUpdateQueue(current, workInProgress, updateQueue, null, null, renderExpirationTime);\n          if (prevState === state) {\n            // If the state is the same as before, that's a bailout because we had\n            // no work that expires at this time.\n            resetHydrationState();\n            return bailoutOnAlreadyFinishedWork(current, workInProgress);\n          }\n          var element = state.element;\n          var root = workInProgress.stateNode;\n          if ((current === null || current.child === null) && root.hydrate && enterHydrationState(workInProgress)) {\n            // If we don't have any current children this might be the first pass.\n            // We always try to hydrate. If this isn't a hydration pass there won't\n            // be any children to hydrate which is effectively the same thing as\n            // not hydrating.\n\n            // This is a bit of a hack. We track the host root as a placement to\n            // know that we're currently in a mounting state. That way isMounted\n            // works as expected. We must reset this before committing.\n            // TODO: Delete this when we delete isMounted and findDOMNode.\n            workInProgress.effectTag |= Placement;\n\n            // Ensure that children mount into this root without tracking\n            // side-effects. This ensures that we don't store Placement effects on\n            // nodes that will be hydrated.\n            workInProgress.child = mountChildFibers(workInProgress, null, element, renderExpirationTime);\n          } else {\n            // Otherwise reset hydration state in case we aborted and resumed another\n            // root.\n            resetHydrationState();\n            reconcileChildren(current, workInProgress, element);\n          }\n          memoizeState(workInProgress, state);\n          return workInProgress.child;\n        }\n        resetHydrationState();\n        // If there is no update queue, that's a bailout because the root has no props.\n        return bailoutOnAlreadyFinishedWork(current, workInProgress);\n      }\n\n      function updateHostComponent(current, workInProgress, renderExpirationTime) {\n        pushHostContext(workInProgress);\n\n        if (current === null) {\n          tryToClaimNextHydratableInstance(workInProgress);\n        }\n\n        var type = workInProgress.type;\n        var memoizedProps = workInProgress.memoizedProps;\n        var nextProps = workInProgress.pendingProps;\n        if (nextProps === null) {\n          nextProps = memoizedProps;\n          !(nextProps !== null) ? invariant(false, 'We should always have pending or current props. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        }\n        var prevProps = current !== null ? current.memoizedProps : null;\n\n        if (hasContextChanged()) {\n          // Normally we can bail out on props equality but if context has changed\n          // we don't do the bailout and we have to reuse existing props instead.\n        } else if (nextProps === null || memoizedProps === nextProps) {\n          return bailoutOnAlreadyFinishedWork(current, workInProgress);\n        }\n\n        var nextChildren = nextProps.children;\n        var isDirectTextChild = shouldSetTextContent(type, nextProps);\n\n        if (isDirectTextChild) {\n          // We special case a direct text child of a host node. This is a common\n          // case. We won't handle it as a reified child. We will instead handle\n          // this in the host environment that also have access to this prop. That\n          // avoids allocating another HostText fiber and traversing it.\n          nextChildren = null;\n        } else if (prevProps && shouldSetTextContent(type, prevProps)) {\n          // If we're switching from a direct text child to a normal child, or to\n          // empty, we need to schedule the text content to be reset.\n          workInProgress.effectTag |= ContentReset;\n        }\n\n        markRef(current, workInProgress);\n\n        // Check the host config to see if the children are offscreen/hidden.\n        if (renderExpirationTime !== Never && !useSyncScheduling && shouldDeprioritizeSubtree(type, nextProps)) {\n          // Down-prioritize the children.\n          workInProgress.expirationTime = Never;\n          // Bailout and come back to this fiber later.\n          return null;\n        }\n\n        reconcileChildren(current, workInProgress, nextChildren);\n        memoizeProps(workInProgress, nextProps);\n        return workInProgress.child;\n      }\n\n      function updateHostText(current, workInProgress) {\n        if (current === null) {\n          tryToClaimNextHydratableInstance(workInProgress);\n        }\n        var nextProps = workInProgress.pendingProps;\n        if (nextProps === null) {\n          nextProps = workInProgress.memoizedProps;\n        }\n        memoizeProps(workInProgress, nextProps);\n        // Nothing to do here. This is terminal. We'll do the completion step\n        // immediately after.\n        return null;\n      }\n\n      function mountIndeterminateComponent(current, workInProgress, renderExpirationTime) {\n        !(current === null) ? invariant(false, 'An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        var fn = workInProgress.type;\n        var props = workInProgress.pendingProps;\n        var unmaskedContext = getUnmaskedContext(workInProgress);\n        var context = getMaskedContext(workInProgress, unmaskedContext);\n\n        var value;\n\n        {\n          if (fn.prototype && typeof fn.prototype.render === 'function') {\n            var componentName = getComponentName(workInProgress);\n            warning(false, \"The <%s /> component appears to have a render method, but doesn't extend React.Component. \" + 'This is likely to cause errors. Change %s to extend React.Component instead.', componentName, componentName);\n          }\n          ReactCurrentOwner.current = workInProgress;\n          value = fn(props, context);\n        }\n        // React DevTools reads this flag.\n        workInProgress.effectTag |= PerformedWork;\n\n        if (typeof value === 'object' && value !== null && typeof value.render === 'function') {\n          // Proceed under the assumption that this is a class instance\n          workInProgress.tag = ClassComponent;\n\n          // Push context providers early to prevent context stack mismatches.\n          // During mounting we don't know the child context yet as the instance doesn't exist.\n          // We will invalidate the child context in finishClassComponent() right after rendering.\n          var hasContext = pushContextProvider(workInProgress);\n          adoptClassInstance(workInProgress, value);\n          mountClassInstance(workInProgress, renderExpirationTime);\n          return finishClassComponent(current, workInProgress, true, hasContext);\n        } else {\n          // Proceed under the assumption that this is a functional component\n          workInProgress.tag = FunctionalComponent;\n          {\n            var Component = workInProgress.type;\n\n            if (Component) {\n              warning(!Component.childContextTypes, '%s(...): childContextTypes cannot be defined on a functional component.', Component.displayName || Component.name || 'Component');\n            }\n            if (workInProgress.ref !== null) {\n              var info = '';\n              var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName();\n              if (ownerName) {\n                info += '\\n\\nCheck the render method of `' + ownerName + '`.';\n              }\n\n              var warningKey = ownerName || workInProgress._debugID || '';\n              var debugSource = workInProgress._debugSource;\n              if (debugSource) {\n                warningKey = debugSource.fileName + ':' + debugSource.lineNumber;\n              }\n              if (!warnedAboutStatelessRefs[warningKey]) {\n                warnedAboutStatelessRefs[warningKey] = true;\n                warning(false, 'Stateless function components cannot be given refs. ' + 'Attempts to access this ref will fail.%s%s', info, ReactDebugCurrentFiber.getCurrentFiberStackAddendum());\n              }\n            }\n          }\n          reconcileChildren(current, workInProgress, value);\n          memoizeProps(workInProgress, props);\n          return workInProgress.child;\n        }\n      }\n\n      function updateCallComponent(current, workInProgress, renderExpirationTime) {\n        var nextCall = workInProgress.pendingProps;\n        if (hasContextChanged()) {\n          // Normally we can bail out on props equality but if context has changed\n          // we don't do the bailout and we have to reuse existing props instead.\n          if (nextCall === null) {\n            nextCall = current && current.memoizedProps;\n            !(nextCall !== null) ? invariant(false, 'We should always have pending or current props. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n          }\n        } else if (nextCall === null || workInProgress.memoizedProps === nextCall) {\n          nextCall = workInProgress.memoizedProps;\n          // TODO: When bailing out, we might need to return the stateNode instead\n          // of the child. To check it for work.\n          // return bailoutOnAlreadyFinishedWork(current, workInProgress);\n        }\n\n        var nextChildren = nextCall.children;\n\n        // The following is a fork of reconcileChildrenAtExpirationTime but using\n        // stateNode to store the child.\n        if (current === null) {\n          workInProgress.stateNode = mountChildFibers(workInProgress, workInProgress.stateNode, nextChildren, renderExpirationTime);\n        } else {\n          workInProgress.stateNode = reconcileChildFibers(workInProgress, workInProgress.stateNode, nextChildren, renderExpirationTime);\n        }\n\n        memoizeProps(workInProgress, nextCall);\n        // This doesn't take arbitrary time so we could synchronously just begin\n        // eagerly do the work of workInProgress.child as an optimization.\n        return workInProgress.stateNode;\n      }\n\n      function updatePortalComponent(current, workInProgress, renderExpirationTime) {\n        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n        var nextChildren = workInProgress.pendingProps;\n        if (hasContextChanged()) {\n          // Normally we can bail out on props equality but if context has changed\n          // we don't do the bailout and we have to reuse existing props instead.\n          if (nextChildren === null) {\n            nextChildren = current && current.memoizedProps;\n            !(nextChildren != null) ? invariant(false, 'We should always have pending or current props. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n          }\n        } else if (nextChildren === null || workInProgress.memoizedProps === nextChildren) {\n          return bailoutOnAlreadyFinishedWork(current, workInProgress);\n        }\n\n        if (current === null) {\n          // Portals are special because we don't append the children during mount\n          // but at commit. Therefore we need to track insertions which the normal\n          // flow doesn't do during mount. This doesn't happen at the root because\n          // the root always starts with a \"current\" with a null child.\n          // TODO: Consider unifying this with how the root works.\n          workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);\n          memoizeProps(workInProgress, nextChildren);\n        } else {\n          reconcileChildren(current, workInProgress, nextChildren);\n          memoizeProps(workInProgress, nextChildren);\n        }\n        return workInProgress.child;\n      }\n\n      /*\n      function reuseChildrenEffects(returnFiber : Fiber, firstChild : Fiber) {\n        let child = firstChild;\n        do {\n          // Ensure that the first and last effect of the parent corresponds\n          // to the children's first and last effect.\n          if (!returnFiber.firstEffect) {\n            returnFiber.firstEffect = child.firstEffect;\n          }\n          if (child.lastEffect) {\n            if (returnFiber.lastEffect) {\n              returnFiber.lastEffect.nextEffect = child.firstEffect;\n            }\n            returnFiber.lastEffect = child.lastEffect;\n          }\n        } while (child = child.sibling);\n      }\n      */\n\n      function bailoutOnAlreadyFinishedWork(current, workInProgress) {\n        cancelWorkTimer(workInProgress);\n\n        // TODO: We should ideally be able to bail out early if the children have no\n        // more work to do. However, since we don't have a separation of this\n        // Fiber's priority and its children yet - we don't know without doing lots\n        // of the same work we do anyway. Once we have that separation we can just\n        // bail out here if the children has no more work at this priority level.\n        // if (workInProgress.priorityOfChildren <= priorityLevel) {\n        //   // If there are side-effects in these children that have not yet been\n        //   // committed we need to ensure that they get properly transferred up.\n        //   if (current && current.child !== workInProgress.child) {\n        //     reuseChildrenEffects(workInProgress, child);\n        //   }\n        //   return null;\n        // }\n\n        cloneChildFibers(current, workInProgress);\n        return workInProgress.child;\n      }\n\n      function bailoutOnLowPriority(current, workInProgress) {\n        cancelWorkTimer(workInProgress);\n\n        // TODO: Handle HostComponent tags here as well and call pushHostContext()?\n        // See PR 8590 discussion for context\n        switch (workInProgress.tag) {\n          case HostRoot:\n            pushHostRootContext(workInProgress);\n            break;\n          case ClassComponent:\n            pushContextProvider(workInProgress);\n            break;\n          case HostPortal:\n            pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);\n            break;\n        }\n        // TODO: What if this is currently in progress?\n        // How can that happen? How is this not being cloned?\n        return null;\n      }\n\n      // TODO: Delete memoizeProps/State and move to reconcile/bailout instead\n      function memoizeProps(workInProgress, nextProps) {\n        workInProgress.memoizedProps = nextProps;\n      }\n\n      function memoizeState(workInProgress, nextState) {\n        workInProgress.memoizedState = nextState;\n        // Don't reset the updateQueue, in case there are pending updates. Resetting\n        // is handled by processUpdateQueue.\n      }\n\n      function beginWork(current, workInProgress, renderExpirationTime) {\n        if (workInProgress.expirationTime === NoWork || workInProgress.expirationTime > renderExpirationTime) {\n          return bailoutOnLowPriority(current, workInProgress);\n        }\n\n        switch (workInProgress.tag) {\n          case IndeterminateComponent:\n            return mountIndeterminateComponent(current, workInProgress, renderExpirationTime);\n          case FunctionalComponent:\n            return updateFunctionalComponent(current, workInProgress);\n          case ClassComponent:\n            return updateClassComponent(current, workInProgress, renderExpirationTime);\n          case HostRoot:\n            return updateHostRoot(current, workInProgress, renderExpirationTime);\n          case HostComponent:\n            return updateHostComponent(current, workInProgress, renderExpirationTime);\n          case HostText:\n            return updateHostText(current, workInProgress);\n          case CallHandlerPhase:\n            // This is a restart. Reset the tag to the initial phase.\n            workInProgress.tag = CallComponent;\n          // Intentionally fall through since this is now the same.\n          case CallComponent:\n            return updateCallComponent(current, workInProgress, renderExpirationTime);\n          case ReturnComponent:\n            // A return component is just a placeholder, we can just run through the\n            // next one immediately.\n            return null;\n          case HostPortal:\n            return updatePortalComponent(current, workInProgress, renderExpirationTime);\n          case Fragment:\n            return updateFragment(current, workInProgress);\n          default:\n            invariant(false, 'Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.');\n        }\n      }\n\n      function beginFailedWork(current, workInProgress, renderExpirationTime) {\n        // Push context providers here to avoid a push/pop context mismatch.\n        switch (workInProgress.tag) {\n          case ClassComponent:\n            pushContextProvider(workInProgress);\n            break;\n          case HostRoot:\n            pushHostRootContext(workInProgress);\n            break;\n          default:\n            invariant(false, 'Invalid type of work. This error is likely caused by a bug in React. Please file an issue.');\n        }\n\n        // Add an error effect so we can handle the error during the commit phase\n        workInProgress.effectTag |= Err;\n\n        // This is a weird case where we do \"resume\" work — work that failed on\n        // our first attempt. Because we no longer have a notion of \"progressed\n        // deletions,\" reset the child to the current child to make sure we delete\n        // it again. TODO: Find a better way to handle this, perhaps during a more\n        // general overhaul of error handling.\n        if (current === null) {\n          workInProgress.child = null;\n        } else if (workInProgress.child !== current.child) {\n          workInProgress.child = current.child;\n        }\n\n        if (workInProgress.expirationTime === NoWork || workInProgress.expirationTime > renderExpirationTime) {\n          return bailoutOnLowPriority(current, workInProgress);\n        }\n\n        // If we don't bail out, we're going be recomputing our children so we need\n        // to drop our effect list.\n        workInProgress.firstEffect = null;\n        workInProgress.lastEffect = null;\n\n        // Unmount the current children as if the component rendered null\n        var nextChildren = null;\n        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime);\n\n        if (workInProgress.tag === ClassComponent) {\n          var instance = workInProgress.stateNode;\n          workInProgress.memoizedProps = instance.props;\n          workInProgress.memoizedState = instance.state;\n        }\n\n        return workInProgress.child;\n      }\n\n      return {\n        beginWork: beginWork,\n        beginFailedWork: beginFailedWork\n      };\n    };\n\n    var ReactFiberCompleteWork = function (config, hostContext, hydrationContext) {\n      var createInstance = config.createInstance,\n          createTextInstance = config.createTextInstance,\n          appendInitialChild = config.appendInitialChild,\n          finalizeInitialChildren = config.finalizeInitialChildren,\n          prepareUpdate = config.prepareUpdate,\n          mutation = config.mutation,\n          persistence = config.persistence;\n      var getRootHostContainer = hostContext.getRootHostContainer,\n          popHostContext = hostContext.popHostContext,\n          getHostContext = hostContext.getHostContext,\n          popHostContainer = hostContext.popHostContainer;\n      var prepareToHydrateHostInstance = hydrationContext.prepareToHydrateHostInstance,\n          prepareToHydrateHostTextInstance = hydrationContext.prepareToHydrateHostTextInstance,\n          popHydrationState = hydrationContext.popHydrationState;\n\n      function markUpdate(workInProgress) {\n        // Tag the fiber with an update effect. This turns a Placement into\n        // an UpdateAndPlacement.\n        workInProgress.effectTag |= Update;\n      }\n\n      function markRef(workInProgress) {\n        workInProgress.effectTag |= Ref;\n      }\n\n      function appendAllReturns(returns, workInProgress) {\n        var node = workInProgress.stateNode;\n        if (node) {\n          node['return'] = workInProgress;\n        }\n        while (node !== null) {\n          if (node.tag === HostComponent || node.tag === HostText || node.tag === HostPortal) {\n            invariant(false, 'A call cannot have host component children.');\n          } else if (node.tag === ReturnComponent) {\n            returns.push(node.type);\n          } else if (node.child !== null) {\n            node.child['return'] = node;\n            node = node.child;\n            continue;\n          }\n          while (node.sibling === null) {\n            if (node['return'] === null || node['return'] === workInProgress) {\n              return;\n            }\n            node = node['return'];\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n        }\n      }\n\n      function moveCallToHandlerPhase(current, workInProgress, renderExpirationTime) {\n        var call = workInProgress.memoizedProps;\n        !call ? invariant(false, 'Should be resolved by now. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n        // First step of the call has completed. Now we need to do the second.\n        // TODO: It would be nice to have a multi stage call represented by a\n        // single component, or at least tail call optimize nested ones. Currently\n        // that requires additional fields that we don't want to add to the fiber.\n        // So this requires nested handlers.\n        // Note: This doesn't mutate the alternate node. I don't think it needs to\n        // since this stage is reset for every pass.\n        workInProgress.tag = CallHandlerPhase;\n\n        // Build up the returns.\n        // TODO: Compare this to a generator or opaque helpers like Children.\n        var returns = [];\n        appendAllReturns(returns, workInProgress);\n        var fn = call.handler;\n        var props = call.props;\n        var nextChildren = fn(props, returns);\n\n        var currentFirstChild = current !== null ? current.child : null;\n        workInProgress.child = reconcileChildFibers(workInProgress, currentFirstChild, nextChildren, renderExpirationTime);\n        return workInProgress.child;\n      }\n\n      function appendAllChildren(parent, workInProgress) {\n        // We only have the top Fiber that was created but we need recurse down its\n        // children to find all the terminal nodes.\n        var node = workInProgress.child;\n        while (node !== null) {\n          if (node.tag === HostComponent || node.tag === HostText) {\n            appendInitialChild(parent, node.stateNode);\n          } else if (node.tag === HostPortal) {\n            // If we have a portal child, then we don't want to traverse\n            // down its children. Instead, we'll get insertions from each child in\n            // the portal directly.\n          } else if (node.child !== null) {\n            node.child['return'] = node;\n            node = node.child;\n            continue;\n          }\n          if (node === workInProgress) {\n            return;\n          }\n          while (node.sibling === null) {\n            if (node['return'] === null || node['return'] === workInProgress) {\n              return;\n            }\n            node = node['return'];\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n        }\n      }\n\n      var updateHostContainer = void 0;\n      var updateHostComponent = void 0;\n      var updateHostText = void 0;\n      if (mutation) {\n        if (enableMutatingReconciler) {\n          // Mutation mode\n          updateHostContainer = function (workInProgress) {\n            // Noop\n          };\n          updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance) {\n            // TODO: Type this specific to this type of component.\n            workInProgress.updateQueue = updatePayload;\n            // If the update payload indicates that there is a change or if there\n            // is a new ref we mark this as an update. All the work is done in commitWork.\n            if (updatePayload) {\n              markUpdate(workInProgress);\n            }\n          };\n          updateHostText = function (current, workInProgress, oldText, newText) {\n            // If the text differs, mark it as an update. All the work in done in commitWork.\n            if (oldText !== newText) {\n              markUpdate(workInProgress);\n            }\n          };\n        } else {\n          invariant(false, 'Mutating reconciler is disabled.');\n        }\n      } else if (persistence) {\n        if (enablePersistentReconciler) {\n          // Persistent host tree mode\n          var cloneInstance = persistence.cloneInstance,\n              createContainerChildSet = persistence.createContainerChildSet,\n              appendChildToContainerChildSet = persistence.appendChildToContainerChildSet,\n              finalizeContainerChildren = persistence.finalizeContainerChildren;\n\n          // An unfortunate fork of appendAllChildren because we have two different parent types.\n\n          var appendAllChildrenToContainer = function (containerChildSet, workInProgress) {\n            // We only have the top Fiber that was created but we need recurse down its\n            // children to find all the terminal nodes.\n            var node = workInProgress.child;\n            while (node !== null) {\n              if (node.tag === HostComponent || node.tag === HostText) {\n                appendChildToContainerChildSet(containerChildSet, node.stateNode);\n              } else if (node.tag === HostPortal) {\n                // If we have a portal child, then we don't want to traverse\n                // down its children. Instead, we'll get insertions from each child in\n                // the portal directly.\n              } else if (node.child !== null) {\n                node.child['return'] = node;\n                node = node.child;\n                continue;\n              }\n              if (node === workInProgress) {\n                return;\n              }\n              while (node.sibling === null) {\n                if (node['return'] === null || node['return'] === workInProgress) {\n                  return;\n                }\n                node = node['return'];\n              }\n              node.sibling['return'] = node['return'];\n              node = node.sibling;\n            }\n          };\n          updateHostContainer = function (workInProgress) {\n            var portalOrRoot = workInProgress.stateNode;\n            var childrenUnchanged = workInProgress.firstEffect === null;\n            if (childrenUnchanged) {\n              // No changes, just reuse the existing instance.\n            } else {\n              var container = portalOrRoot.containerInfo;\n              var newChildSet = createContainerChildSet(container);\n              if (finalizeContainerChildren(container, newChildSet)) {\n                markUpdate(workInProgress);\n              }\n              portalOrRoot.pendingChildren = newChildSet;\n              // If children might have changed, we have to add them all to the set.\n              appendAllChildrenToContainer(newChildSet, workInProgress);\n              // Schedule an update on the container to swap out the container.\n              markUpdate(workInProgress);\n            }\n          };\n          updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance) {\n            // If there are no effects associated with this node, then none of our children had any updates.\n            // This guarantees that we can reuse all of them.\n            var childrenUnchanged = workInProgress.firstEffect === null;\n            var currentInstance = current.stateNode;\n            if (childrenUnchanged && updatePayload === null) {\n              // No changes, just reuse the existing instance.\n              // Note that this might release a previous clone.\n              workInProgress.stateNode = currentInstance;\n            } else {\n              var recyclableInstance = workInProgress.stateNode;\n              var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);\n              if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance)) {\n                markUpdate(workInProgress);\n              }\n              workInProgress.stateNode = newInstance;\n              if (childrenUnchanged) {\n                // If there are no other effects in this tree, we need to flag this node as having one.\n                // Even though we're not going to use it for anything.\n                // Otherwise parents won't know that there are new children to propagate upwards.\n                markUpdate(workInProgress);\n              } else {\n                // If children might have changed, we have to add them all to the set.\n                appendAllChildren(newInstance, workInProgress);\n              }\n            }\n          };\n          updateHostText = function (current, workInProgress, oldText, newText) {\n            if (oldText !== newText) {\n              // If the text content differs, we'll create a new text instance for it.\n              var rootContainerInstance = getRootHostContainer();\n              var currentHostContext = getHostContext();\n              workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);\n              // We'll have to mark it as having an effect, even though we won't use the effect for anything.\n              // This lets the parents know that at least one of their children has changed.\n              markUpdate(workInProgress);\n            }\n          };\n        } else {\n          invariant(false, 'Persistent reconciler is disabled.');\n        }\n      } else {\n        if (enableNoopReconciler) {\n          // No host operations\n          updateHostContainer = function (workInProgress) {\n            // Noop\n          };\n          updateHostComponent = function (current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance) {\n            // Noop\n          };\n          updateHostText = function (current, workInProgress, oldText, newText) {\n            // Noop\n          };\n        } else {\n          invariant(false, 'Noop reconciler is disabled.');\n        }\n      }\n\n      function completeWork(current, workInProgress, renderExpirationTime) {\n        // Get the latest props.\n        var newProps = workInProgress.pendingProps;\n        if (newProps === null) {\n          newProps = workInProgress.memoizedProps;\n        } else if (workInProgress.expirationTime !== Never || renderExpirationTime === Never) {\n          // Reset the pending props, unless this was a down-prioritization.\n          workInProgress.pendingProps = null;\n        }\n\n        switch (workInProgress.tag) {\n          case FunctionalComponent:\n            return null;\n          case ClassComponent:\n            {\n              // We are leaving this subtree, so pop context if any.\n              popContextProvider(workInProgress);\n              return null;\n            }\n          case HostRoot:\n            {\n              popHostContainer(workInProgress);\n              popTopLevelContextObject(workInProgress);\n              var fiberRoot = workInProgress.stateNode;\n              if (fiberRoot.pendingContext) {\n                fiberRoot.context = fiberRoot.pendingContext;\n                fiberRoot.pendingContext = null;\n              }\n\n              if (current === null || current.child === null) {\n                // If we hydrated, pop so that we can delete any remaining children\n                // that weren't hydrated.\n                popHydrationState(workInProgress);\n                // This resets the hacky state to fix isMounted before committing.\n                // TODO: Delete this when we delete isMounted and findDOMNode.\n                workInProgress.effectTag &= ~Placement;\n              }\n              updateHostContainer(workInProgress);\n              return null;\n            }\n          case HostComponent:\n            {\n              popHostContext(workInProgress);\n              var rootContainerInstance = getRootHostContainer();\n              var type = workInProgress.type;\n              if (current !== null && workInProgress.stateNode != null) {\n                // If we have an alternate, that means this is an update and we need to\n                // schedule a side-effect to do the updates.\n                var oldProps = current.memoizedProps;\n                // If we get updated because one of our children updated, we don't\n                // have newProps so we'll have to reuse them.\n                // TODO: Split the update API as separate for the props vs. children.\n                // Even better would be if children weren't special cased at all tho.\n                var instance = workInProgress.stateNode;\n                var currentHostContext = getHostContext();\n                var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);\n\n                updateHostComponent(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance);\n\n                if (current.ref !== workInProgress.ref) {\n                  markRef(workInProgress);\n                }\n              } else {\n                if (!newProps) {\n                  !(workInProgress.stateNode !== null) ? invariant(false, 'We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n                  // This can happen when we abort work.\n                  return null;\n                }\n\n                var _currentHostContext = getHostContext();\n                // TODO: Move createInstance to beginWork and keep it on a context\n                // \"stack\" as the parent. Then append children as we go in beginWork\n                // or completeWork depending on we want to add then top->down or\n                // bottom->up. Top->down is faster in IE11.\n                var wasHydrated = popHydrationState(workInProgress);\n                if (wasHydrated) {\n                  // TODO: Move this and createInstance step into the beginPhase\n                  // to consolidate.\n                  if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, _currentHostContext)) {\n                    // If changes to the hydrated node needs to be applied at the\n                    // commit-phase we mark this as such.\n                    markUpdate(workInProgress);\n                  }\n                } else {\n                  var _instance = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress);\n\n                  appendAllChildren(_instance, workInProgress);\n\n                  // Certain renderers require commit-time effects for initial mount.\n                  // (eg DOM renderer supports auto-focus for certain elements).\n                  // Make sure such renderers get scheduled for later work.\n                  if (finalizeInitialChildren(_instance, type, newProps, rootContainerInstance)) {\n                    markUpdate(workInProgress);\n                  }\n                  workInProgress.stateNode = _instance;\n                }\n\n                if (workInProgress.ref !== null) {\n                  // If there is a ref on a host node we need to schedule a callback\n                  markRef(workInProgress);\n                }\n              }\n              return null;\n            }\n          case HostText:\n            {\n              var newText = newProps;\n              if (current && workInProgress.stateNode != null) {\n                var oldText = current.memoizedProps;\n                // If we have an alternate, that means this is an update and we need\n                // to schedule a side-effect to do the updates.\n                updateHostText(current, workInProgress, oldText, newText);\n              } else {\n                if (typeof newText !== 'string') {\n                  !(workInProgress.stateNode !== null) ? invariant(false, 'We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n                  // This can happen when we abort work.\n                  return null;\n                }\n                var _rootContainerInstance = getRootHostContainer();\n                var _currentHostContext2 = getHostContext();\n                var _wasHydrated = popHydrationState(workInProgress);\n                if (_wasHydrated) {\n                  if (prepareToHydrateHostTextInstance(workInProgress)) {\n                    markUpdate(workInProgress);\n                  }\n                } else {\n                  workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress);\n                }\n              }\n              return null;\n            }\n          case CallComponent:\n            return moveCallToHandlerPhase(current, workInProgress, renderExpirationTime);\n          case CallHandlerPhase:\n            // Reset the tag to now be a first phase call.\n            workInProgress.tag = CallComponent;\n            return null;\n          case ReturnComponent:\n            // Does nothing.\n            return null;\n          case Fragment:\n            return null;\n          case HostPortal:\n            popHostContainer(workInProgress);\n            updateHostContainer(workInProgress);\n            return null;\n          // Error cases\n          case IndeterminateComponent:\n            invariant(false, 'An indeterminate component should have become determinate before completing. This error is likely caused by a bug in React. Please file an issue.');\n          // eslint-disable-next-line no-fallthrough\n          default:\n            invariant(false, 'Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.');\n        }\n      }\n\n      return {\n        completeWork: completeWork\n      };\n    };\n\n    var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback;\n    var hasCaughtError$1 = ReactErrorUtils.hasCaughtError;\n    var clearCaughtError$1 = ReactErrorUtils.clearCaughtError;\n\n    var ReactFiberCommitWork = function (config, captureError) {\n      var getPublicInstance = config.getPublicInstance,\n          mutation = config.mutation,\n          persistence = config.persistence;\n\n      var callComponentWillUnmountWithTimer = function (current, instance) {\n        startPhaseTimer(current, 'componentWillUnmount');\n        instance.props = current.memoizedProps;\n        instance.state = current.memoizedState;\n        instance.componentWillUnmount();\n        stopPhaseTimer();\n      };\n\n      // Capture errors so they don't interrupt unmounting.\n      function safelyCallComponentWillUnmount(current, instance) {\n        {\n          invokeGuardedCallback$2(null, callComponentWillUnmountWithTimer, null, current, instance);\n          if (hasCaughtError$1()) {\n            var unmountError = clearCaughtError$1();\n            captureError(current, unmountError);\n          }\n        }\n      }\n\n      function safelyDetachRef(current) {\n        var ref = current.ref;\n        if (ref !== null) {\n          {\n            invokeGuardedCallback$2(null, ref, null, null);\n            if (hasCaughtError$1()) {\n              var refError = clearCaughtError$1();\n              captureError(current, refError);\n            }\n          }\n        }\n      }\n\n      function commitLifeCycles(current, finishedWork) {\n        switch (finishedWork.tag) {\n          case ClassComponent:\n            {\n              var instance = finishedWork.stateNode;\n              if (finishedWork.effectTag & Update) {\n                if (current === null) {\n                  startPhaseTimer(finishedWork, 'componentDidMount');\n                  instance.props = finishedWork.memoizedProps;\n                  instance.state = finishedWork.memoizedState;\n                  instance.componentDidMount();\n                  stopPhaseTimer();\n                } else {\n                  var prevProps = current.memoizedProps;\n                  var prevState = current.memoizedState;\n                  startPhaseTimer(finishedWork, 'componentDidUpdate');\n                  instance.props = finishedWork.memoizedProps;\n                  instance.state = finishedWork.memoizedState;\n                  instance.componentDidUpdate(prevProps, prevState);\n                  stopPhaseTimer();\n                }\n              }\n              var updateQueue = finishedWork.updateQueue;\n              if (updateQueue !== null) {\n                commitCallbacks(updateQueue, instance);\n              }\n              return;\n            }\n          case HostRoot:\n            {\n              var _updateQueue = finishedWork.updateQueue;\n              if (_updateQueue !== null) {\n                var _instance = finishedWork.child !== null ? finishedWork.child.stateNode : null;\n                commitCallbacks(_updateQueue, _instance);\n              }\n              return;\n            }\n          case HostComponent:\n            {\n              var _instance2 = finishedWork.stateNode;\n\n              // Renderers may schedule work to be done after host components are mounted\n              // (eg DOM renderer may schedule auto-focus for inputs and form controls).\n              // These effects should only be committed when components are first mounted,\n              // aka when there is no current/alternate.\n              if (current === null && finishedWork.effectTag & Update) {\n                var type = finishedWork.type;\n                var props = finishedWork.memoizedProps;\n                commitMount(_instance2, type, props, finishedWork);\n              }\n\n              return;\n            }\n          case HostText:\n            {\n              // We have no life-cycles associated with text.\n              return;\n            }\n          case HostPortal:\n            {\n              // We have no life-cycles associated with portals.\n              return;\n            }\n          default:\n            {\n              invariant(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.');\n            }\n        }\n      }\n\n      function commitAttachRef(finishedWork) {\n        var ref = finishedWork.ref;\n        if (ref !== null) {\n          var instance = finishedWork.stateNode;\n          switch (finishedWork.tag) {\n            case HostComponent:\n              ref(getPublicInstance(instance));\n              break;\n            default:\n              ref(instance);\n          }\n        }\n      }\n\n      function commitDetachRef(current) {\n        var currentRef = current.ref;\n        if (currentRef !== null) {\n          currentRef(null);\n        }\n      }\n\n      // User-originating errors (lifecycles and refs) should not interrupt\n      // deletion, so don't let them throw. Host-originating errors should\n      // interrupt deletion, so it's okay\n      function commitUnmount(current) {\n        if (typeof onCommitUnmount === 'function') {\n          onCommitUnmount(current);\n        }\n\n        switch (current.tag) {\n          case ClassComponent:\n            {\n              safelyDetachRef(current);\n              var instance = current.stateNode;\n              if (typeof instance.componentWillUnmount === 'function') {\n                safelyCallComponentWillUnmount(current, instance);\n              }\n              return;\n            }\n          case HostComponent:\n            {\n              safelyDetachRef(current);\n              return;\n            }\n          case CallComponent:\n            {\n              commitNestedUnmounts(current.stateNode);\n              return;\n            }\n          case HostPortal:\n            {\n              // TODO: this is recursive.\n              // We are also not using this parent because\n              // the portal will get pushed immediately.\n              if (enableMutatingReconciler && mutation) {\n                unmountHostComponents(current);\n              } else if (enablePersistentReconciler && persistence) {\n                emptyPortalContainer(current);\n              }\n              return;\n            }\n        }\n      }\n\n      function commitNestedUnmounts(root) {\n        // While we're inside a removed host node we don't want to call\n        // removeChild on the inner nodes because they're removed by the top\n        // call anyway. We also want to call componentWillUnmount on all\n        // composites before this host node is removed from the tree. Therefore\n        var node = root;\n        while (true) {\n          commitUnmount(node);\n          // Visit children because they may contain more composite or host nodes.\n          // Skip portals because commitUnmount() currently visits them recursively.\n          if (node.child !== null && (\n          // If we use mutation we drill down into portals using commitUnmount above.\n          // If we don't use mutation we drill down into portals here instead.\n          !mutation || node.tag !== HostPortal)) {\n            node.child['return'] = node;\n            node = node.child;\n            continue;\n          }\n          if (node === root) {\n            return;\n          }\n          while (node.sibling === null) {\n            if (node['return'] === null || node['return'] === root) {\n              return;\n            }\n            node = node['return'];\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n        }\n      }\n\n      function detachFiber(current) {\n        // Cut off the return pointers to disconnect it from the tree. Ideally, we\n        // should clear the child pointer of the parent alternate to let this\n        // get GC:ed but we don't know which for sure which parent is the current\n        // one so we'll settle for GC:ing the subtree of this child. This child\n        // itself will be GC:ed when the parent updates the next time.\n        current['return'] = null;\n        current.child = null;\n        if (current.alternate) {\n          current.alternate.child = null;\n          current.alternate['return'] = null;\n        }\n      }\n\n      if (!mutation) {\n        var commitContainer = void 0;\n        if (persistence) {\n          var replaceContainerChildren = persistence.replaceContainerChildren,\n              createContainerChildSet = persistence.createContainerChildSet;\n\n          var emptyPortalContainer = function (current) {\n            var portal = current.stateNode;\n            var containerInfo = portal.containerInfo;\n\n            var emptyChildSet = createContainerChildSet(containerInfo);\n            replaceContainerChildren(containerInfo, emptyChildSet);\n          };\n          commitContainer = function (finishedWork) {\n            switch (finishedWork.tag) {\n              case ClassComponent:\n                {\n                  return;\n                }\n              case HostComponent:\n                {\n                  return;\n                }\n              case HostText:\n                {\n                  return;\n                }\n              case HostRoot:\n              case HostPortal:\n                {\n                  var portalOrRoot = finishedWork.stateNode;\n                  var containerInfo = portalOrRoot.containerInfo,\n                      _pendingChildren = portalOrRoot.pendingChildren;\n\n                  replaceContainerChildren(containerInfo, _pendingChildren);\n                  return;\n                }\n              default:\n                {\n                  invariant(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.');\n                }\n            }\n          };\n        } else {\n          commitContainer = function (finishedWork) {\n            // Noop\n          };\n        }\n        if (enablePersistentReconciler || enableNoopReconciler) {\n          return {\n            commitResetTextContent: function (finishedWork) {},\n            commitPlacement: function (finishedWork) {},\n            commitDeletion: function (current) {\n              // Detach refs and call componentWillUnmount() on the whole subtree.\n              commitNestedUnmounts(current);\n              detachFiber(current);\n            },\n            commitWork: function (current, finishedWork) {\n              commitContainer(finishedWork);\n            },\n\n            commitLifeCycles: commitLifeCycles,\n            commitAttachRef: commitAttachRef,\n            commitDetachRef: commitDetachRef\n          };\n        } else if (persistence) {\n          invariant(false, 'Persistent reconciler is disabled.');\n        } else {\n          invariant(false, 'Noop reconciler is disabled.');\n        }\n      }\n      var commitMount = mutation.commitMount,\n          commitUpdate = mutation.commitUpdate,\n          resetTextContent = mutation.resetTextContent,\n          commitTextUpdate = mutation.commitTextUpdate,\n          appendChild = mutation.appendChild,\n          appendChildToContainer = mutation.appendChildToContainer,\n          insertBefore = mutation.insertBefore,\n          insertInContainerBefore = mutation.insertInContainerBefore,\n          removeChild = mutation.removeChild,\n          removeChildFromContainer = mutation.removeChildFromContainer;\n\n      function getHostParentFiber(fiber) {\n        var parent = fiber['return'];\n        while (parent !== null) {\n          if (isHostParent(parent)) {\n            return parent;\n          }\n          parent = parent['return'];\n        }\n        invariant(false, 'Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.');\n      }\n\n      function isHostParent(fiber) {\n        return fiber.tag === HostComponent || fiber.tag === HostRoot || fiber.tag === HostPortal;\n      }\n\n      function getHostSibling(fiber) {\n        // We're going to search forward into the tree until we find a sibling host\n        // node. Unfortunately, if multiple insertions are done in a row we have to\n        // search past them. This leads to exponential search for the next sibling.\n        var node = fiber;\n        siblings: while (true) {\n          // If we didn't find anything, let's try the next sibling.\n          while (node.sibling === null) {\n            if (node['return'] === null || isHostParent(node['return'])) {\n              // If we pop out of the root or hit the parent the fiber we are the\n              // last sibling.\n              return null;\n            }\n            node = node['return'];\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n          while (node.tag !== HostComponent && node.tag !== HostText) {\n            // If it is not host node and, we might have a host node inside it.\n            // Try to search down until we find one.\n            if (node.effectTag & Placement) {\n              // If we don't have a child, try the siblings instead.\n              continue siblings;\n            }\n            // If we don't have a child, try the siblings instead.\n            // We also skip portals because they are not part of this host tree.\n            if (node.child === null || node.tag === HostPortal) {\n              continue siblings;\n            } else {\n              node.child['return'] = node;\n              node = node.child;\n            }\n          }\n          // Check if this host node is stable or about to be placed.\n          if (!(node.effectTag & Placement)) {\n            // Found it!\n            return node.stateNode;\n          }\n        }\n      }\n\n      function commitPlacement(finishedWork) {\n        // Recursively insert all host nodes into the parent.\n        var parentFiber = getHostParentFiber(finishedWork);\n        var parent = void 0;\n        var isContainer = void 0;\n        switch (parentFiber.tag) {\n          case HostComponent:\n            parent = parentFiber.stateNode;\n            isContainer = false;\n            break;\n          case HostRoot:\n            parent = parentFiber.stateNode.containerInfo;\n            isContainer = true;\n            break;\n          case HostPortal:\n            parent = parentFiber.stateNode.containerInfo;\n            isContainer = true;\n            break;\n          default:\n            invariant(false, 'Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue.');\n        }\n        if (parentFiber.effectTag & ContentReset) {\n          // Reset the text content of the parent before doing any insertions\n          resetTextContent(parent);\n          // Clear ContentReset from the effect tag\n          parentFiber.effectTag &= ~ContentReset;\n        }\n\n        var before = getHostSibling(finishedWork);\n        // We only have the top Fiber that was inserted but we need recurse down its\n        // children to find all the terminal nodes.\n        var node = finishedWork;\n        while (true) {\n          if (node.tag === HostComponent || node.tag === HostText) {\n            if (before) {\n              if (isContainer) {\n                insertInContainerBefore(parent, node.stateNode, before);\n              } else {\n                insertBefore(parent, node.stateNode, before);\n              }\n            } else {\n              if (isContainer) {\n                appendChildToContainer(parent, node.stateNode);\n              } else {\n                appendChild(parent, node.stateNode);\n              }\n            }\n          } else if (node.tag === HostPortal) {\n            // If the insertion itself is a portal, then we don't want to traverse\n            // down its children. Instead, we'll get insertions from each child in\n            // the portal directly.\n          } else if (node.child !== null) {\n            node.child['return'] = node;\n            node = node.child;\n            continue;\n          }\n          if (node === finishedWork) {\n            return;\n          }\n          while (node.sibling === null) {\n            if (node['return'] === null || node['return'] === finishedWork) {\n              return;\n            }\n            node = node['return'];\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n        }\n      }\n\n      function unmountHostComponents(current) {\n        // We only have the top Fiber that was inserted but we need recurse down its\n        var node = current;\n\n        // Each iteration, currentParent is populated with node's host parent if not\n        // currentParentIsValid.\n        var currentParentIsValid = false;\n        var currentParent = void 0;\n        var currentParentIsContainer = void 0;\n\n        while (true) {\n          if (!currentParentIsValid) {\n            var parent = node['return'];\n            findParent: while (true) {\n              !(parent !== null) ? invariant(false, 'Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n              switch (parent.tag) {\n                case HostComponent:\n                  currentParent = parent.stateNode;\n                  currentParentIsContainer = false;\n                  break findParent;\n                case HostRoot:\n                  currentParent = parent.stateNode.containerInfo;\n                  currentParentIsContainer = true;\n                  break findParent;\n                case HostPortal:\n                  currentParent = parent.stateNode.containerInfo;\n                  currentParentIsContainer = true;\n                  break findParent;\n              }\n              parent = parent['return'];\n            }\n            currentParentIsValid = true;\n          }\n\n          if (node.tag === HostComponent || node.tag === HostText) {\n            commitNestedUnmounts(node);\n            // After all the children have unmounted, it is now safe to remove the\n            // node from the tree.\n            if (currentParentIsContainer) {\n              removeChildFromContainer(currentParent, node.stateNode);\n            } else {\n              removeChild(currentParent, node.stateNode);\n            }\n            // Don't visit children because we already visited them.\n          } else if (node.tag === HostPortal) {\n            // When we go into a portal, it becomes the parent to remove from.\n            // We will reassign it back when we pop the portal on the way up.\n            currentParent = node.stateNode.containerInfo;\n            // Visit children because portals might contain host components.\n            if (node.child !== null) {\n              node.child['return'] = node;\n              node = node.child;\n              continue;\n            }\n          } else {\n            commitUnmount(node);\n            // Visit children because we may find more host components below.\n            if (node.child !== null) {\n              node.child['return'] = node;\n              node = node.child;\n              continue;\n            }\n          }\n          if (node === current) {\n            return;\n          }\n          while (node.sibling === null) {\n            if (node['return'] === null || node['return'] === current) {\n              return;\n            }\n            node = node['return'];\n            if (node.tag === HostPortal) {\n              // When we go out of the portal, we need to restore the parent.\n              // Since we don't keep a stack of them, we will search for it.\n              currentParentIsValid = false;\n            }\n          }\n          node.sibling['return'] = node['return'];\n          node = node.sibling;\n        }\n      }\n\n      function commitDeletion(current) {\n        // Recursively delete all host nodes from the parent.\n        // Detach refs and call componentWillUnmount() on the whole subtree.\n        unmountHostComponents(current);\n        detachFiber(current);\n      }\n\n      function commitWork(current, finishedWork) {\n        switch (finishedWork.tag) {\n          case ClassComponent:\n            {\n              return;\n            }\n          case HostComponent:\n            {\n              var instance = finishedWork.stateNode;\n              if (instance != null) {\n                // Commit the work prepared earlier.\n                var newProps = finishedWork.memoizedProps;\n                // For hydration we reuse the update path but we treat the oldProps\n                // as the newProps. The updatePayload will contain the real change in\n                // this case.\n                var oldProps = current !== null ? current.memoizedProps : newProps;\n                var type = finishedWork.type;\n                // TODO: Type the updateQueue to be specific to host components.\n                var updatePayload = finishedWork.updateQueue;\n                finishedWork.updateQueue = null;\n                if (updatePayload !== null) {\n                  commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);\n                }\n              }\n              return;\n            }\n          case HostText:\n            {\n              !(finishedWork.stateNode !== null) ? invariant(false, 'This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n              var textInstance = finishedWork.stateNode;\n              var newText = finishedWork.memoizedProps;\n              // For hydration we reuse the update path but we treat the oldProps\n              // as the newProps. The updatePayload will contain the real change in\n              // this case.\n              var oldText = current !== null ? current.memoizedProps : newText;\n              commitTextUpdate(textInstance, oldText, newText);\n              return;\n            }\n          case HostRoot:\n            {\n              return;\n            }\n          default:\n            {\n              invariant(false, 'This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue.');\n            }\n        }\n      }\n\n      function commitResetTextContent(current) {\n        resetTextContent(current.stateNode);\n      }\n\n      if (enableMutatingReconciler) {\n        return {\n          commitResetTextContent: commitResetTextContent,\n          commitPlacement: commitPlacement,\n          commitDeletion: commitDeletion,\n          commitWork: commitWork,\n          commitLifeCycles: commitLifeCycles,\n          commitAttachRef: commitAttachRef,\n          commitDetachRef: commitDetachRef\n        };\n      } else {\n        invariant(false, 'Mutating reconciler is disabled.');\n      }\n    };\n\n    var NO_CONTEXT = {};\n\n    var ReactFiberHostContext = function (config) {\n      var getChildHostContext = config.getChildHostContext,\n          getRootHostContext = config.getRootHostContext;\n\n      var contextStackCursor = createCursor(NO_CONTEXT);\n      var contextFiberStackCursor = createCursor(NO_CONTEXT);\n      var rootInstanceStackCursor = createCursor(NO_CONTEXT);\n\n      function requiredContext(c) {\n        !(c !== NO_CONTEXT) ? invariant(false, 'Expected host context to exist. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        return c;\n      }\n\n      function getRootHostContainer() {\n        var rootInstance = requiredContext(rootInstanceStackCursor.current);\n        return rootInstance;\n      }\n\n      function pushHostContainer(fiber, nextRootInstance) {\n        // Push current root instance onto the stack;\n        // This allows us to reset root when portals are popped.\n        push(rootInstanceStackCursor, nextRootInstance, fiber);\n\n        var nextRootContext = getRootHostContext(nextRootInstance);\n\n        // Track the context and the Fiber that provided it.\n        // This enables us to pop only Fibers that provide unique contexts.\n        push(contextFiberStackCursor, fiber, fiber);\n        push(contextStackCursor, nextRootContext, fiber);\n      }\n\n      function popHostContainer(fiber) {\n        pop(contextStackCursor, fiber);\n        pop(contextFiberStackCursor, fiber);\n        pop(rootInstanceStackCursor, fiber);\n      }\n\n      function getHostContext() {\n        var context = requiredContext(contextStackCursor.current);\n        return context;\n      }\n\n      function pushHostContext(fiber) {\n        var rootInstance = requiredContext(rootInstanceStackCursor.current);\n        var context = requiredContext(contextStackCursor.current);\n        var nextContext = getChildHostContext(context, fiber.type, rootInstance);\n\n        // Don't push this Fiber's context unless it's unique.\n        if (context === nextContext) {\n          return;\n        }\n\n        // Track the context and the Fiber that provided it.\n        // This enables us to pop only Fibers that provide unique contexts.\n        push(contextFiberStackCursor, fiber, fiber);\n        push(contextStackCursor, nextContext, fiber);\n      }\n\n      function popHostContext(fiber) {\n        // Do not pop unless this Fiber provided the current context.\n        // pushHostContext() only pushes Fibers that provide unique contexts.\n        if (contextFiberStackCursor.current !== fiber) {\n          return;\n        }\n\n        pop(contextStackCursor, fiber);\n        pop(contextFiberStackCursor, fiber);\n      }\n\n      function resetHostContainer() {\n        contextStackCursor.current = NO_CONTEXT;\n        rootInstanceStackCursor.current = NO_CONTEXT;\n      }\n\n      return {\n        getHostContext: getHostContext,\n        getRootHostContainer: getRootHostContainer,\n        popHostContainer: popHostContainer,\n        popHostContext: popHostContext,\n        pushHostContainer: pushHostContainer,\n        pushHostContext: pushHostContext,\n        resetHostContainer: resetHostContainer\n      };\n    };\n\n    var ReactFiberHydrationContext = function (config) {\n      var shouldSetTextContent = config.shouldSetTextContent,\n          hydration = config.hydration;\n\n      // If this doesn't have hydration mode.\n\n      if (!hydration) {\n        return {\n          enterHydrationState: function () {\n            return false;\n          },\n          resetHydrationState: function () {},\n          tryToClaimNextHydratableInstance: function () {},\n          prepareToHydrateHostInstance: function () {\n            invariant(false, 'Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.');\n          },\n          prepareToHydrateHostTextInstance: function () {\n            invariant(false, 'Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue.');\n          },\n          popHydrationState: function (fiber) {\n            return false;\n          }\n        };\n      }\n\n      var canHydrateInstance = hydration.canHydrateInstance,\n          canHydrateTextInstance = hydration.canHydrateTextInstance,\n          getNextHydratableSibling = hydration.getNextHydratableSibling,\n          getFirstHydratableChild = hydration.getFirstHydratableChild,\n          hydrateInstance = hydration.hydrateInstance,\n          hydrateTextInstance = hydration.hydrateTextInstance,\n          didNotMatchHydratedContainerTextInstance = hydration.didNotMatchHydratedContainerTextInstance,\n          didNotMatchHydratedTextInstance = hydration.didNotMatchHydratedTextInstance,\n          didNotHydrateContainerInstance = hydration.didNotHydrateContainerInstance,\n          didNotHydrateInstance = hydration.didNotHydrateInstance,\n          didNotFindHydratableContainerInstance = hydration.didNotFindHydratableContainerInstance,\n          didNotFindHydratableContainerTextInstance = hydration.didNotFindHydratableContainerTextInstance,\n          didNotFindHydratableInstance = hydration.didNotFindHydratableInstance,\n          didNotFindHydratableTextInstance = hydration.didNotFindHydratableTextInstance;\n\n      // The deepest Fiber on the stack involved in a hydration context.\n      // This may have been an insertion or a hydration.\n\n      var hydrationParentFiber = null;\n      var nextHydratableInstance = null;\n      var isHydrating = false;\n\n      function enterHydrationState(fiber) {\n        var parentInstance = fiber.stateNode.containerInfo;\n        nextHydratableInstance = getFirstHydratableChild(parentInstance);\n        hydrationParentFiber = fiber;\n        isHydrating = true;\n        return true;\n      }\n\n      function deleteHydratableInstance(returnFiber, instance) {\n        {\n          switch (returnFiber.tag) {\n            case HostRoot:\n              didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);\n              break;\n            case HostComponent:\n              didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);\n              break;\n          }\n        }\n\n        var childToDelete = createFiberFromHostInstanceForDeletion();\n        childToDelete.stateNode = instance;\n        childToDelete['return'] = returnFiber;\n        childToDelete.effectTag = Deletion;\n\n        // This might seem like it belongs on progressedFirstDeletion. However,\n        // these children are not part of the reconciliation list of children.\n        // Even if we abort and rereconcile the children, that will try to hydrate\n        // again and the nodes are still in the host tree so these will be\n        // recreated.\n        if (returnFiber.lastEffect !== null) {\n          returnFiber.lastEffect.nextEffect = childToDelete;\n          returnFiber.lastEffect = childToDelete;\n        } else {\n          returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;\n        }\n      }\n\n      function insertNonHydratedInstance(returnFiber, fiber) {\n        fiber.effectTag |= Placement;\n        {\n          switch (returnFiber.tag) {\n            case HostRoot:\n              {\n                var parentContainer = returnFiber.stateNode.containerInfo;\n                switch (fiber.tag) {\n                  case HostComponent:\n                    var type = fiber.type;\n                    var props = fiber.pendingProps;\n                    didNotFindHydratableContainerInstance(parentContainer, type, props);\n                    break;\n                  case HostText:\n                    var text = fiber.pendingProps;\n                    didNotFindHydratableContainerTextInstance(parentContainer, text);\n                    break;\n                }\n                break;\n              }\n            case HostComponent:\n              {\n                var parentType = returnFiber.type;\n                var parentProps = returnFiber.memoizedProps;\n                var parentInstance = returnFiber.stateNode;\n                switch (fiber.tag) {\n                  case HostComponent:\n                    var _type = fiber.type;\n                    var _props = fiber.pendingProps;\n                    didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);\n                    break;\n                  case HostText:\n                    var _text = fiber.pendingProps;\n                    didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);\n                    break;\n                }\n                break;\n              }\n            default:\n              return;\n          }\n        }\n      }\n\n      function tryHydrate(fiber, nextInstance) {\n        switch (fiber.tag) {\n          case HostComponent:\n            {\n              var type = fiber.type;\n              var props = fiber.pendingProps;\n              var instance = canHydrateInstance(nextInstance, type, props);\n              if (instance !== null) {\n                fiber.stateNode = instance;\n                return true;\n              }\n              return false;\n            }\n          case HostText:\n            {\n              var text = fiber.pendingProps;\n              var textInstance = canHydrateTextInstance(nextInstance, text);\n              if (textInstance !== null) {\n                fiber.stateNode = textInstance;\n                return true;\n              }\n              return false;\n            }\n          default:\n            return false;\n        }\n      }\n\n      function tryToClaimNextHydratableInstance(fiber) {\n        if (!isHydrating) {\n          return;\n        }\n        var nextInstance = nextHydratableInstance;\n        if (!nextInstance) {\n          // Nothing to hydrate. Make it an insertion.\n          insertNonHydratedInstance(hydrationParentFiber, fiber);\n          isHydrating = false;\n          hydrationParentFiber = fiber;\n          return;\n        }\n        if (!tryHydrate(fiber, nextInstance)) {\n          // If we can't hydrate this instance let's try the next one.\n          // We use this as a heuristic. It's based on intuition and not data so it\n          // might be flawed or unnecessary.\n          nextInstance = getNextHydratableSibling(nextInstance);\n          if (!nextInstance || !tryHydrate(fiber, nextInstance)) {\n            // Nothing to hydrate. Make it an insertion.\n            insertNonHydratedInstance(hydrationParentFiber, fiber);\n            isHydrating = false;\n            hydrationParentFiber = fiber;\n            return;\n          }\n          // We matched the next one, we'll now assume that the first one was\n          // superfluous and we'll delete it. Since we can't eagerly delete it\n          // we'll have to schedule a deletion. To do that, this node needs a dummy\n          // fiber associated with it.\n          deleteHydratableInstance(hydrationParentFiber, nextHydratableInstance);\n        }\n        hydrationParentFiber = fiber;\n        nextHydratableInstance = getFirstHydratableChild(nextInstance);\n      }\n\n      function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {\n        var instance = fiber.stateNode;\n        var updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, hostContext, fiber);\n        // TODO: Type this specific to this type of component.\n        fiber.updateQueue = updatePayload;\n        // If the update payload indicates that there is a change or if there\n        // is a new ref we mark this as an update.\n        if (updatePayload !== null) {\n          return true;\n        }\n        return false;\n      }\n\n      function prepareToHydrateHostTextInstance(fiber) {\n        var textInstance = fiber.stateNode;\n        var textContent = fiber.memoizedProps;\n        var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);\n        {\n          if (shouldUpdate) {\n            // We assume that prepareToHydrateHostTextInstance is called in a context where the\n            // hydration parent is the parent host component of this host text.\n            var returnFiber = hydrationParentFiber;\n            if (returnFiber !== null) {\n              switch (returnFiber.tag) {\n                case HostRoot:\n                  {\n                    var parentContainer = returnFiber.stateNode.containerInfo;\n                    didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent);\n                    break;\n                  }\n                case HostComponent:\n                  {\n                    var parentType = returnFiber.type;\n                    var parentProps = returnFiber.memoizedProps;\n                    var parentInstance = returnFiber.stateNode;\n                    didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent);\n                    break;\n                  }\n              }\n            }\n          }\n        }\n        return shouldUpdate;\n      }\n\n      function popToNextHostParent(fiber) {\n        var parent = fiber['return'];\n        while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot) {\n          parent = parent['return'];\n        }\n        hydrationParentFiber = parent;\n      }\n\n      function popHydrationState(fiber) {\n        if (fiber !== hydrationParentFiber) {\n          // We're deeper than the current hydration context, inside an inserted\n          // tree.\n          return false;\n        }\n        if (!isHydrating) {\n          // If we're not currently hydrating but we're in a hydration context, then\n          // we were an insertion and now need to pop up reenter hydration of our\n          // siblings.\n          popToNextHostParent(fiber);\n          isHydrating = true;\n          return false;\n        }\n\n        var type = fiber.type;\n\n        // If we have any remaining hydratable nodes, we need to delete them now.\n        // We only do this deeper than head and body since they tend to have random\n        // other nodes in them. We also ignore components with pure text content in\n        // side of them.\n        // TODO: Better heuristic.\n        if (fiber.tag !== HostComponent || type !== 'head' && type !== 'body' && !shouldSetTextContent(type, fiber.memoizedProps)) {\n          var nextInstance = nextHydratableInstance;\n          while (nextInstance) {\n            deleteHydratableInstance(fiber, nextInstance);\n            nextInstance = getNextHydratableSibling(nextInstance);\n          }\n        }\n\n        popToNextHostParent(fiber);\n        nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;\n        return true;\n      }\n\n      function resetHydrationState() {\n        hydrationParentFiber = null;\n        nextHydratableInstance = null;\n        isHydrating = false;\n      }\n\n      return {\n        enterHydrationState: enterHydrationState,\n        resetHydrationState: resetHydrationState,\n        tryToClaimNextHydratableInstance: tryToClaimNextHydratableInstance,\n        prepareToHydrateHostInstance: prepareToHydrateHostInstance,\n        prepareToHydrateHostTextInstance: prepareToHydrateHostTextInstance,\n        popHydrationState: popHydrationState\n      };\n    };\n\n    // This lets us hook into Fiber to debug what it's doing.\n    // See https://github.com/facebook/react/pull/8033.\n    // This is not part of the public API, not even for React DevTools.\n    // You may only inject a debugTool if you work on React Fiber itself.\n    var ReactFiberInstrumentation = {\n      debugTool: null\n    };\n\n    var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;\n\n    var defaultShowDialog = function (capturedError) {\n      return true;\n    };\n\n    var showDialog = defaultShowDialog;\n\n    function logCapturedError(capturedError) {\n      var logError = showDialog(capturedError);\n\n      // Allow injected showDialog() to prevent default console.error logging.\n      // This enables renderers like ReactNative to better manage redbox behavior.\n      if (logError === false) {\n        return;\n      }\n\n      var error = capturedError.error;\n      var suppressLogging = error && error.suppressReactErrorLogging;\n      if (suppressLogging) {\n        return;\n      }\n\n      {\n        var componentName = capturedError.componentName,\n            componentStack = capturedError.componentStack,\n            errorBoundaryName = capturedError.errorBoundaryName,\n            errorBoundaryFound = capturedError.errorBoundaryFound,\n            willRetry = capturedError.willRetry;\n\n        var componentNameMessage = componentName ? 'The above error occurred in the <' + componentName + '> component:' : 'The above error occurred in one of your React components:';\n\n        var errorBoundaryMessage = void 0;\n        // errorBoundaryFound check is sufficient; errorBoundaryName check is to satisfy Flow.\n        if (errorBoundaryFound && errorBoundaryName) {\n          if (willRetry) {\n            errorBoundaryMessage = 'React will try to recreate this component tree from scratch ' + ('using the error boundary you provided, ' + errorBoundaryName + '.');\n          } else {\n            errorBoundaryMessage = 'This error was initially handled by the error boundary ' + errorBoundaryName + '.\\n' + 'Recreating the tree from scratch failed so React will unmount the tree.';\n          }\n        } else {\n          errorBoundaryMessage = 'Consider adding an error boundary to your tree to customize error handling behavior.\\n' + 'Visit https://fb.me/react-error-boundaries to learn more about error boundaries.';\n        }\n        var combinedMessage = '' + componentNameMessage + componentStack + '\\n\\n' + ('' + errorBoundaryMessage);\n\n        // In development, we provide our own message with just the component stack.\n        // We don't include the original error message and JS stack because the browser\n        // has already printed it. Even if the application swallows the error, it is still\n        // displayed by the browser thanks to the DEV-only fake event trick in ReactErrorUtils.\n        console.error(combinedMessage);\n      }\n    }\n\n    var invokeGuardedCallback$1 = ReactErrorUtils.invokeGuardedCallback;\n    var hasCaughtError = ReactErrorUtils.hasCaughtError;\n    var clearCaughtError = ReactErrorUtils.clearCaughtError;\n\n    {\n      var didWarnAboutStateTransition = false;\n      var didWarnSetStateChildContext = false;\n      var didWarnStateUpdateForUnmountedComponent = {};\n\n      var warnAboutUpdateOnUnmounted = function (fiber) {\n        var componentName = getComponentName(fiber) || 'ReactClass';\n        if (didWarnStateUpdateForUnmountedComponent[componentName]) {\n          return;\n        }\n        warning(false, 'Can only update a mounted or mounting ' + 'component. This usually means you called setState, replaceState, ' + 'or forceUpdate on an unmounted component. This is a no-op.\\n\\nPlease ' + 'check the code for the %s component.', componentName);\n        didWarnStateUpdateForUnmountedComponent[componentName] = true;\n      };\n\n      var warnAboutInvalidUpdates = function (instance) {\n        switch (ReactDebugCurrentFiber.phase) {\n          case 'getChildContext':\n            if (didWarnSetStateChildContext) {\n              return;\n            }\n            warning(false, 'setState(...): Cannot call setState() inside getChildContext()');\n            didWarnSetStateChildContext = true;\n            break;\n          case 'render':\n            if (didWarnAboutStateTransition) {\n              return;\n            }\n            warning(false, 'Cannot update during an existing state transition (such as within ' + \"`render` or another component's constructor). Render methods should \" + 'be a pure function of props and state; constructor side-effects are ' + 'an anti-pattern, but can be moved to `componentWillMount`.');\n            didWarnAboutStateTransition = true;\n            break;\n        }\n      };\n    }\n\n    var ReactFiberScheduler = function (config) {\n      var hostContext = ReactFiberHostContext(config);\n      var hydrationContext = ReactFiberHydrationContext(config);\n      var popHostContainer = hostContext.popHostContainer,\n          popHostContext = hostContext.popHostContext,\n          resetHostContainer = hostContext.resetHostContainer;\n\n      var _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, hydrationContext, scheduleWork, computeExpirationForFiber),\n          beginWork = _ReactFiberBeginWork.beginWork,\n          beginFailedWork = _ReactFiberBeginWork.beginFailedWork;\n\n      var _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, hydrationContext),\n          completeWork = _ReactFiberCompleteWo.completeWork;\n\n      var _ReactFiberCommitWork = ReactFiberCommitWork(config, captureError),\n          commitResetTextContent = _ReactFiberCommitWork.commitResetTextContent,\n          commitPlacement = _ReactFiberCommitWork.commitPlacement,\n          commitDeletion = _ReactFiberCommitWork.commitDeletion,\n          commitWork = _ReactFiberCommitWork.commitWork,\n          commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles,\n          commitAttachRef = _ReactFiberCommitWork.commitAttachRef,\n          commitDetachRef = _ReactFiberCommitWork.commitDetachRef;\n\n      var now = config.now,\n          scheduleDeferredCallback = config.scheduleDeferredCallback,\n          cancelDeferredCallback = config.cancelDeferredCallback,\n          useSyncScheduling = config.useSyncScheduling,\n          prepareForCommit = config.prepareForCommit,\n          resetAfterCommit = config.resetAfterCommit;\n\n      // Represents the current time in ms.\n\n      var startTime = now();\n      var mostRecentCurrentTime = msToExpirationTime(0);\n\n      // Represents the expiration time that incoming updates should use. (If this\n      // is NoWork, use the default strategy: async updates in async mode, sync\n      // updates in sync mode.)\n      var expirationContext = NoWork;\n\n      var isWorking = false;\n\n      // The next work in progress fiber that we're currently working on.\n      var nextUnitOfWork = null;\n      var nextRoot = null;\n      // The time at which we're currently rendering work.\n      var nextRenderExpirationTime = NoWork;\n\n      // The next fiber with an effect that we're currently committing.\n      var nextEffect = null;\n\n      // Keep track of which fibers have captured an error that need to be handled.\n      // Work is removed from this collection after componentDidCatch is called.\n      var capturedErrors = null;\n      // Keep track of which fibers have failed during the current batch of work.\n      // This is a different set than capturedErrors, because it is not reset until\n      // the end of the batch. This is needed to propagate errors correctly if a\n      // subtree fails more than once.\n      var failedBoundaries = null;\n      // Error boundaries that captured an error during the current commit.\n      var commitPhaseBoundaries = null;\n      var firstUncaughtError = null;\n      var didFatal = false;\n\n      var isCommitting = false;\n      var isUnmounting = false;\n\n      // Used for performance tracking.\n      var interruptedBy = null;\n\n      function resetContextStack() {\n        // Reset the stack\n        reset$1();\n        // Reset the cursors\n        resetContext();\n        resetHostContainer();\n      }\n\n      function commitAllHostEffects() {\n        while (nextEffect !== null) {\n          {\n            ReactDebugCurrentFiber.setCurrentFiber(nextEffect);\n          }\n          recordEffect();\n\n          var effectTag = nextEffect.effectTag;\n          if (effectTag & ContentReset) {\n            commitResetTextContent(nextEffect);\n          }\n\n          if (effectTag & Ref) {\n            var current = nextEffect.alternate;\n            if (current !== null) {\n              commitDetachRef(current);\n            }\n          }\n\n          // The following switch statement is only concerned about placement,\n          // updates, and deletions. To avoid needing to add a case for every\n          // possible bitmap value, we remove the secondary effects from the\n          // effect tag and switch on that value.\n          var primaryEffectTag = effectTag & ~(Callback | Err | ContentReset | Ref | PerformedWork);\n          switch (primaryEffectTag) {\n            case Placement:\n              {\n                commitPlacement(nextEffect);\n                // Clear the \"placement\" from effect tag so that we know that this is inserted, before\n                // any life-cycles like componentDidMount gets called.\n                // TODO: findDOMNode doesn't rely on this any more but isMounted\n                // does and isMounted is deprecated anyway so we should be able\n                // to kill this.\n                nextEffect.effectTag &= ~Placement;\n                break;\n              }\n            case PlacementAndUpdate:\n              {\n                // Placement\n                commitPlacement(nextEffect);\n                // Clear the \"placement\" from effect tag so that we know that this is inserted, before\n                // any life-cycles like componentDidMount gets called.\n                nextEffect.effectTag &= ~Placement;\n\n                // Update\n                var _current = nextEffect.alternate;\n                commitWork(_current, nextEffect);\n                break;\n              }\n            case Update:\n              {\n                var _current2 = nextEffect.alternate;\n                commitWork(_current2, nextEffect);\n                break;\n              }\n            case Deletion:\n              {\n                isUnmounting = true;\n                commitDeletion(nextEffect);\n                isUnmounting = false;\n                break;\n              }\n          }\n          nextEffect = nextEffect.nextEffect;\n        }\n\n        {\n          ReactDebugCurrentFiber.resetCurrentFiber();\n        }\n      }\n\n      function commitAllLifeCycles() {\n        while (nextEffect !== null) {\n          var effectTag = nextEffect.effectTag;\n\n          if (effectTag & (Update | Callback)) {\n            recordEffect();\n            var current = nextEffect.alternate;\n            commitLifeCycles(current, nextEffect);\n          }\n\n          if (effectTag & Ref) {\n            recordEffect();\n            commitAttachRef(nextEffect);\n          }\n\n          if (effectTag & Err) {\n            recordEffect();\n            commitErrorHandling(nextEffect);\n          }\n\n          var next = nextEffect.nextEffect;\n          // Ensure that we clean these up so that we don't accidentally keep them.\n          // I'm not actually sure this matters because we can't reset firstEffect\n          // and lastEffect since they're on every node, not just the effectful\n          // ones. So we have to clean everything as we reuse nodes anyway.\n          nextEffect.nextEffect = null;\n          // Ensure that we reset the effectTag here so that we can rely on effect\n          // tags to reason about the current life-cycle.\n          nextEffect = next;\n        }\n      }\n\n      function commitRoot(finishedWork) {\n        // We keep track of this so that captureError can collect any boundaries\n        // that capture an error during the commit phase. The reason these aren't\n        // local to this function is because errors that occur during cWU are\n        // captured elsewhere, to prevent the unmount from being interrupted.\n        isWorking = true;\n        isCommitting = true;\n        startCommitTimer();\n\n        var root = finishedWork.stateNode;\n        !(root.current !== finishedWork) ? invariant(false, 'Cannot commit the same tree as before. This is probably a bug related to the return field. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        root.isReadyForCommit = false;\n\n        // Reset this to null before calling lifecycles\n        ReactCurrentOwner.current = null;\n\n        var firstEffect = void 0;\n        if (finishedWork.effectTag > PerformedWork) {\n          // A fiber's effect list consists only of its children, not itself. So if\n          // the root has an effect, we need to add it to the end of the list. The\n          // resulting list is the set that would belong to the root's parent, if\n          // it had one; that is, all the effects in the tree including the root.\n          if (finishedWork.lastEffect !== null) {\n            finishedWork.lastEffect.nextEffect = finishedWork;\n            firstEffect = finishedWork.firstEffect;\n          } else {\n            firstEffect = finishedWork;\n          }\n        } else {\n          // There is no effect on the root.\n          firstEffect = finishedWork.firstEffect;\n        }\n\n        prepareForCommit();\n\n        // Commit all the side-effects within a tree. We'll do this in two passes.\n        // The first pass performs all the host insertions, updates, deletions and\n        // ref unmounts.\n        nextEffect = firstEffect;\n        startCommitHostEffectsTimer();\n        while (nextEffect !== null) {\n          var didError = false;\n          var _error = void 0;\n          {\n            invokeGuardedCallback$1(null, commitAllHostEffects, null);\n            if (hasCaughtError()) {\n              didError = true;\n              _error = clearCaughtError();\n            }\n          }\n          if (didError) {\n            !(nextEffect !== null) ? invariant(false, 'Should have next effect. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n            captureError(nextEffect, _error);\n            // Clean-up\n            if (nextEffect !== null) {\n              nextEffect = nextEffect.nextEffect;\n            }\n          }\n        }\n        stopCommitHostEffectsTimer();\n\n        resetAfterCommit();\n\n        // The work-in-progress tree is now the current tree. This must come after\n        // the first pass of the commit phase, so that the previous tree is still\n        // current during componentWillUnmount, but before the second pass, so that\n        // the finished work is current during componentDidMount/Update.\n        root.current = finishedWork;\n\n        // In the second pass we'll perform all life-cycles and ref callbacks.\n        // Life-cycles happen as a separate pass so that all placements, updates,\n        // and deletions in the entire tree have already been invoked.\n        // This pass also triggers any renderer-specific initial effects.\n        nextEffect = firstEffect;\n        startCommitLifeCyclesTimer();\n        while (nextEffect !== null) {\n          var _didError = false;\n          var _error2 = void 0;\n          {\n            invokeGuardedCallback$1(null, commitAllLifeCycles, null);\n            if (hasCaughtError()) {\n              _didError = true;\n              _error2 = clearCaughtError();\n            }\n          }\n          if (_didError) {\n            !(nextEffect !== null) ? invariant(false, 'Should have next effect. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n            captureError(nextEffect, _error2);\n            if (nextEffect !== null) {\n              nextEffect = nextEffect.nextEffect;\n            }\n          }\n        }\n\n        isCommitting = false;\n        isWorking = false;\n        stopCommitLifeCyclesTimer();\n        stopCommitTimer();\n        if (typeof onCommitRoot === 'function') {\n          onCommitRoot(finishedWork.stateNode);\n        }\n        if (true && ReactFiberInstrumentation_1.debugTool) {\n          ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);\n        }\n\n        // If we caught any errors during this commit, schedule their boundaries\n        // to update.\n        if (commitPhaseBoundaries) {\n          commitPhaseBoundaries.forEach(scheduleErrorRecovery);\n          commitPhaseBoundaries = null;\n        }\n\n        if (firstUncaughtError !== null) {\n          var _error3 = firstUncaughtError;\n          firstUncaughtError = null;\n          onUncaughtError(_error3);\n        }\n\n        var remainingTime = root.current.expirationTime;\n\n        if (remainingTime === NoWork) {\n          capturedErrors = null;\n          failedBoundaries = null;\n        }\n\n        return remainingTime;\n      }\n\n      function resetExpirationTime(workInProgress, renderTime) {\n        if (renderTime !== Never && workInProgress.expirationTime === Never) {\n          // The children of this component are hidden. Don't bubble their\n          // expiration times.\n          return;\n        }\n\n        // Check for pending updates.\n        var newExpirationTime = getUpdateExpirationTime(workInProgress);\n\n        // TODO: Calls need to visit stateNode\n\n        // Bubble up the earliest expiration time.\n        var child = workInProgress.child;\n        while (child !== null) {\n          if (child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > child.expirationTime)) {\n            newExpirationTime = child.expirationTime;\n          }\n          child = child.sibling;\n        }\n        workInProgress.expirationTime = newExpirationTime;\n      }\n\n      function completeUnitOfWork(workInProgress) {\n        while (true) {\n          // The current, flushed, state of this fiber is the alternate.\n          // Ideally nothing should rely on this, but relying on it here\n          // means that we don't need an additional field on the work in\n          // progress.\n          var current = workInProgress.alternate;\n          {\n            ReactDebugCurrentFiber.setCurrentFiber(workInProgress);\n          }\n          var next = completeWork(current, workInProgress, nextRenderExpirationTime);\n          {\n            ReactDebugCurrentFiber.resetCurrentFiber();\n          }\n\n          var returnFiber = workInProgress['return'];\n          var siblingFiber = workInProgress.sibling;\n\n          resetExpirationTime(workInProgress, nextRenderExpirationTime);\n\n          if (next !== null) {\n            stopWorkTimer(workInProgress);\n            if (true && ReactFiberInstrumentation_1.debugTool) {\n              ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);\n            }\n            // If completing this work spawned new work, do that next. We'll come\n            // back here again.\n            return next;\n          }\n\n          if (returnFiber !== null) {\n            // Append all the effects of the subtree and this fiber onto the effect\n            // list of the parent. The completion order of the children affects the\n            // side-effect order.\n            if (returnFiber.firstEffect === null) {\n              returnFiber.firstEffect = workInProgress.firstEffect;\n            }\n            if (workInProgress.lastEffect !== null) {\n              if (returnFiber.lastEffect !== null) {\n                returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;\n              }\n              returnFiber.lastEffect = workInProgress.lastEffect;\n            }\n\n            // If this fiber had side-effects, we append it AFTER the children's\n            // side-effects. We can perform certain side-effects earlier if\n            // needed, by doing multiple passes over the effect list. We don't want\n            // to schedule our own side-effect on our own list because if end up\n            // reusing children we'll schedule this effect onto itself since we're\n            // at the end.\n            var effectTag = workInProgress.effectTag;\n            // Skip both NoWork and PerformedWork tags when creating the effect list.\n            // PerformedWork effect is read by React DevTools but shouldn't be committed.\n            if (effectTag > PerformedWork) {\n              if (returnFiber.lastEffect !== null) {\n                returnFiber.lastEffect.nextEffect = workInProgress;\n              } else {\n                returnFiber.firstEffect = workInProgress;\n              }\n              returnFiber.lastEffect = workInProgress;\n            }\n          }\n\n          stopWorkTimer(workInProgress);\n          if (true && ReactFiberInstrumentation_1.debugTool) {\n            ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);\n          }\n\n          if (siblingFiber !== null) {\n            // If there is more work to do in this returnFiber, do that next.\n            return siblingFiber;\n          } else if (returnFiber !== null) {\n            // If there's no more work in this returnFiber. Complete the returnFiber.\n            workInProgress = returnFiber;\n            continue;\n          } else {\n            // We've reached the root.\n            var root = workInProgress.stateNode;\n            root.isReadyForCommit = true;\n            return null;\n          }\n        }\n\n        // Without this explicit null return Flow complains of invalid return type\n        // TODO Remove the above while(true) loop\n        // eslint-disable-next-line no-unreachable\n        return null;\n      }\n\n      function performUnitOfWork(workInProgress) {\n        // The current, flushed, state of this fiber is the alternate.\n        // Ideally nothing should rely on this, but relying on it here\n        // means that we don't need an additional field on the work in\n        // progress.\n        var current = workInProgress.alternate;\n\n        // See if beginning this work spawns more work.\n        startWorkTimer(workInProgress);\n        {\n          ReactDebugCurrentFiber.setCurrentFiber(workInProgress);\n        }\n\n        var next = beginWork(current, workInProgress, nextRenderExpirationTime);\n        {\n          ReactDebugCurrentFiber.resetCurrentFiber();\n        }\n        if (true && ReactFiberInstrumentation_1.debugTool) {\n          ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);\n        }\n\n        if (next === null) {\n          // If this doesn't spawn new work, complete the current work.\n          next = completeUnitOfWork(workInProgress);\n        }\n\n        ReactCurrentOwner.current = null;\n\n        return next;\n      }\n\n      function performFailedUnitOfWork(workInProgress) {\n        // The current, flushed, state of this fiber is the alternate.\n        // Ideally nothing should rely on this, but relying on it here\n        // means that we don't need an additional field on the work in\n        // progress.\n        var current = workInProgress.alternate;\n\n        // See if beginning this work spawns more work.\n        startWorkTimer(workInProgress);\n        {\n          ReactDebugCurrentFiber.setCurrentFiber(workInProgress);\n        }\n        var next = beginFailedWork(current, workInProgress, nextRenderExpirationTime);\n        {\n          ReactDebugCurrentFiber.resetCurrentFiber();\n        }\n        if (true && ReactFiberInstrumentation_1.debugTool) {\n          ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);\n        }\n\n        if (next === null) {\n          // If this doesn't spawn new work, complete the current work.\n          next = completeUnitOfWork(workInProgress);\n        }\n\n        ReactCurrentOwner.current = null;\n\n        return next;\n      }\n\n      function workLoop(expirationTime) {\n        if (capturedErrors !== null) {\n          // If there are unhandled errors, switch to the slow work loop.\n          // TODO: How to avoid this check in the fast path? Maybe the renderer\n          // could keep track of which roots have unhandled errors and call a\n          // forked version of renderRoot.\n          slowWorkLoopThatChecksForFailedWork(expirationTime);\n          return;\n        }\n        if (nextRenderExpirationTime === NoWork || nextRenderExpirationTime > expirationTime) {\n          return;\n        }\n\n        if (nextRenderExpirationTime <= mostRecentCurrentTime) {\n          // Flush all expired work.\n          while (nextUnitOfWork !== null) {\n            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n          }\n        } else {\n          // Flush asynchronous work until the deadline runs out of time.\n          while (nextUnitOfWork !== null && !shouldYield()) {\n            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n          }\n        }\n      }\n\n      function slowWorkLoopThatChecksForFailedWork(expirationTime) {\n        if (nextRenderExpirationTime === NoWork || nextRenderExpirationTime > expirationTime) {\n          return;\n        }\n\n        if (nextRenderExpirationTime <= mostRecentCurrentTime) {\n          // Flush all expired work.\n          while (nextUnitOfWork !== null) {\n            if (hasCapturedError(nextUnitOfWork)) {\n              // Use a forked version of performUnitOfWork\n              nextUnitOfWork = performFailedUnitOfWork(nextUnitOfWork);\n            } else {\n              nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n            }\n          }\n        } else {\n          // Flush asynchronous work until the deadline runs out of time.\n          while (nextUnitOfWork !== null && !shouldYield()) {\n            if (hasCapturedError(nextUnitOfWork)) {\n              // Use a forked version of performUnitOfWork\n              nextUnitOfWork = performFailedUnitOfWork(nextUnitOfWork);\n            } else {\n              nextUnitOfWork = performUnitOfWork(nextUnitOfWork);\n            }\n          }\n        }\n      }\n\n      function renderRootCatchBlock(root, failedWork, boundary, expirationTime) {\n        // We're going to restart the error boundary that captured the error.\n        // Conceptually, we're unwinding the stack. We need to unwind the\n        // context stack, too.\n        unwindContexts(failedWork, boundary);\n\n        // Restart the error boundary using a forked version of\n        // performUnitOfWork that deletes the boundary's children. The entire\n        // failed subree will be unmounted. During the commit phase, a special\n        // lifecycle method is called on the error boundary, which triggers\n        // a re-render.\n        nextUnitOfWork = performFailedUnitOfWork(boundary);\n\n        // Continue working.\n        workLoop(expirationTime);\n      }\n\n      function renderRoot(root, expirationTime) {\n        !!isWorking ? invariant(false, 'renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        isWorking = true;\n\n        // We're about to mutate the work-in-progress tree. If the root was pending\n        // commit, it no longer is: we'll need to complete it again.\n        root.isReadyForCommit = false;\n\n        // Check if we're starting from a fresh stack, or if we're resuming from\n        // previously yielded work.\n        if (root !== nextRoot || expirationTime !== nextRenderExpirationTime || nextUnitOfWork === null) {\n          // Reset the stack and start working from the root.\n          resetContextStack();\n          nextRoot = root;\n          nextRenderExpirationTime = expirationTime;\n          nextUnitOfWork = createWorkInProgress(nextRoot.current, null, expirationTime);\n        }\n\n        startWorkLoopTimer(nextUnitOfWork);\n\n        var didError = false;\n        var error = null;\n        {\n          invokeGuardedCallback$1(null, workLoop, null, expirationTime);\n          if (hasCaughtError()) {\n            didError = true;\n            error = clearCaughtError();\n          }\n        }\n\n        // An error was thrown during the render phase.\n        while (didError) {\n          if (didFatal) {\n            // This was a fatal error. Don't attempt to recover from it.\n            firstUncaughtError = error;\n            break;\n          }\n\n          var failedWork = nextUnitOfWork;\n          if (failedWork === null) {\n            // An error was thrown but there's no current unit of work. This can\n            // happen during the commit phase if there's a bug in the renderer.\n            didFatal = true;\n            continue;\n          }\n\n          // \"Capture\" the error by finding the nearest boundary. If there is no\n          // error boundary, we use the root.\n          var boundary = captureError(failedWork, error);\n          !(boundary !== null) ? invariant(false, 'Should have found an error boundary. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n          if (didFatal) {\n            // The error we just captured was a fatal error. This happens\n            // when the error propagates to the root more than once.\n            continue;\n          }\n\n          didError = false;\n          error = null;\n          {\n            invokeGuardedCallback$1(null, renderRootCatchBlock, null, root, failedWork, boundary, expirationTime);\n            if (hasCaughtError()) {\n              didError = true;\n              error = clearCaughtError();\n              continue;\n            }\n          }\n          // We're finished working. Exit the error loop.\n          break;\n        }\n\n        var uncaughtError = firstUncaughtError;\n\n        // We're done performing work. Time to clean up.\n        stopWorkLoopTimer(interruptedBy);\n        interruptedBy = null;\n        isWorking = false;\n        didFatal = false;\n        firstUncaughtError = null;\n\n        if (uncaughtError !== null) {\n          onUncaughtError(uncaughtError);\n        }\n\n        return root.isReadyForCommit ? root.current.alternate : null;\n      }\n\n      // Returns the boundary that captured the error, or null if the error is ignored\n      function captureError(failedWork, error) {\n        // It is no longer valid because we exited the user code.\n        ReactCurrentOwner.current = null;\n        {\n          ReactDebugCurrentFiber.resetCurrentFiber();\n        }\n\n        // Search for the nearest error boundary.\n        var boundary = null;\n\n        // Passed to logCapturedError()\n        var errorBoundaryFound = false;\n        var willRetry = false;\n        var errorBoundaryName = null;\n\n        // Host containers are a special case. If the failed work itself is a host\n        // container, then it acts as its own boundary. In all other cases, we\n        // ignore the work itself and only search through the parents.\n        if (failedWork.tag === HostRoot) {\n          boundary = failedWork;\n\n          if (isFailedBoundary(failedWork)) {\n            // If this root already failed, there must have been an error when\n            // attempting to unmount it. This is a worst-case scenario and\n            // should only be possible if there's a bug in the renderer.\n            didFatal = true;\n          }\n        } else {\n          var node = failedWork['return'];\n          while (node !== null && boundary === null) {\n            if (node.tag === ClassComponent) {\n              var instance = node.stateNode;\n              if (typeof instance.componentDidCatch === 'function') {\n                errorBoundaryFound = true;\n                errorBoundaryName = getComponentName(node);\n\n                // Found an error boundary!\n                boundary = node;\n                willRetry = true;\n              }\n            } else if (node.tag === HostRoot) {\n              // Treat the root like a no-op error boundary\n              boundary = node;\n            }\n\n            if (isFailedBoundary(node)) {\n              // This boundary is already in a failed state.\n\n              // If we're currently unmounting, that means this error was\n              // thrown while unmounting a failed subtree. We should ignore\n              // the error.\n              if (isUnmounting) {\n                return null;\n              }\n\n              // If we're in the commit phase, we should check to see if\n              // this boundary already captured an error during this commit.\n              // This case exists because multiple errors can be thrown during\n              // a single commit without interruption.\n              if (commitPhaseBoundaries !== null && (commitPhaseBoundaries.has(node) || node.alternate !== null && commitPhaseBoundaries.has(node.alternate))) {\n                // If so, we should ignore this error.\n                return null;\n              }\n\n              // The error should propagate to the next boundary -— we keep looking.\n              boundary = null;\n              willRetry = false;\n            }\n\n            node = node['return'];\n          }\n        }\n\n        if (boundary !== null) {\n          // Add to the collection of failed boundaries. This lets us know that\n          // subsequent errors in this subtree should propagate to the next boundary.\n          if (failedBoundaries === null) {\n            failedBoundaries = new Set();\n          }\n          failedBoundaries.add(boundary);\n\n          // This method is unsafe outside of the begin and complete phases.\n          // We might be in the commit phase when an error is captured.\n          // The risk is that the return path from this Fiber may not be accurate.\n          // That risk is acceptable given the benefit of providing users more context.\n          var _componentStack = getStackAddendumByWorkInProgressFiber(failedWork);\n          var _componentName = getComponentName(failedWork);\n\n          // Add to the collection of captured errors. This is stored as a global\n          // map of errors and their component stack location keyed by the boundaries\n          // that capture them. We mostly use this Map as a Set; it's a Map only to\n          // avoid adding a field to Fiber to store the error.\n          if (capturedErrors === null) {\n            capturedErrors = new Map();\n          }\n\n          var capturedError = {\n            componentName: _componentName,\n            componentStack: _componentStack,\n            error: error,\n            errorBoundary: errorBoundaryFound ? boundary.stateNode : null,\n            errorBoundaryFound: errorBoundaryFound,\n            errorBoundaryName: errorBoundaryName,\n            willRetry: willRetry\n          };\n\n          capturedErrors.set(boundary, capturedError);\n\n          try {\n            logCapturedError(capturedError);\n          } catch (e) {\n            // Prevent cycle if logCapturedError() throws.\n            // A cycle may still occur if logCapturedError renders a component that throws.\n            var suppressLogging = e && e.suppressReactErrorLogging;\n            if (!suppressLogging) {\n              console.error(e);\n            }\n          }\n\n          // If we're in the commit phase, defer scheduling an update on the\n          // boundary until after the commit is complete\n          if (isCommitting) {\n            if (commitPhaseBoundaries === null) {\n              commitPhaseBoundaries = new Set();\n            }\n            commitPhaseBoundaries.add(boundary);\n          } else {\n            // Otherwise, schedule an update now.\n            // TODO: Is this actually necessary during the render phase? Is it\n            // possible to unwind and continue rendering at the same priority,\n            // without corrupting internal state?\n            scheduleErrorRecovery(boundary);\n          }\n          return boundary;\n        } else if (firstUncaughtError === null) {\n          // If no boundary is found, we'll need to throw the error\n          firstUncaughtError = error;\n        }\n        return null;\n      }\n\n      function hasCapturedError(fiber) {\n        // TODO: capturedErrors should store the boundary instance, to avoid needing\n        // to check the alternate.\n        return capturedErrors !== null && (capturedErrors.has(fiber) || fiber.alternate !== null && capturedErrors.has(fiber.alternate));\n      }\n\n      function isFailedBoundary(fiber) {\n        // TODO: failedBoundaries should store the boundary instance, to avoid\n        // needing to check the alternate.\n        return failedBoundaries !== null && (failedBoundaries.has(fiber) || fiber.alternate !== null && failedBoundaries.has(fiber.alternate));\n      }\n\n      function commitErrorHandling(effectfulFiber) {\n        var capturedError = void 0;\n        if (capturedErrors !== null) {\n          capturedError = capturedErrors.get(effectfulFiber);\n          capturedErrors['delete'](effectfulFiber);\n          if (capturedError == null) {\n            if (effectfulFiber.alternate !== null) {\n              effectfulFiber = effectfulFiber.alternate;\n              capturedError = capturedErrors.get(effectfulFiber);\n              capturedErrors['delete'](effectfulFiber);\n            }\n          }\n        }\n\n        !(capturedError != null) ? invariant(false, 'No error for given unit of work. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n        switch (effectfulFiber.tag) {\n          case ClassComponent:\n            var instance = effectfulFiber.stateNode;\n\n            var info = {\n              componentStack: capturedError.componentStack\n            };\n\n            // Allow the boundary to handle the error, usually by scheduling\n            // an update to itself\n            instance.componentDidCatch(capturedError.error, info);\n            return;\n          case HostRoot:\n            if (firstUncaughtError === null) {\n              firstUncaughtError = capturedError.error;\n            }\n            return;\n          default:\n            invariant(false, 'Invalid type of work. This error is likely caused by a bug in React. Please file an issue.');\n        }\n      }\n\n      function unwindContexts(from, to) {\n        var node = from;\n        while (node !== null) {\n          switch (node.tag) {\n            case ClassComponent:\n              popContextProvider(node);\n              break;\n            case HostComponent:\n              popHostContext(node);\n              break;\n            case HostRoot:\n              popHostContainer(node);\n              break;\n            case HostPortal:\n              popHostContainer(node);\n              break;\n          }\n          if (node === to || node.alternate === to) {\n            stopFailedWorkTimer(node);\n            break;\n          } else {\n            stopWorkTimer(node);\n          }\n          node = node['return'];\n        }\n      }\n\n      function computeAsyncExpiration() {\n        // Given the current clock time, returns an expiration time. We use rounding\n        // to batch like updates together.\n        // Should complete within ~1000ms. 1200ms max.\n        var currentTime = recalculateCurrentTime();\n        var expirationMs = 1000;\n        var bucketSizeMs = 200;\n        return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);\n      }\n\n      function computeExpirationForFiber(fiber) {\n        var expirationTime = void 0;\n        if (expirationContext !== NoWork) {\n          // An explicit expiration context was set;\n          expirationTime = expirationContext;\n        } else if (isWorking) {\n          if (isCommitting) {\n            // Updates that occur during the commit phase should have sync priority\n            // by default.\n            expirationTime = Sync;\n          } else {\n            // Updates during the render phase should expire at the same time as\n            // the work that is being rendered.\n            expirationTime = nextRenderExpirationTime;\n          }\n        } else {\n          // No explicit expiration context was set, and we're not currently\n          // performing work. Calculate a new expiration time.\n          if (useSyncScheduling && !(fiber.internalContextTag & AsyncUpdates)) {\n            // This is a sync update\n            expirationTime = Sync;\n          } else {\n            // This is an async update\n            expirationTime = computeAsyncExpiration();\n          }\n        }\n        return expirationTime;\n      }\n\n      function scheduleWork(fiber, expirationTime) {\n        return scheduleWorkImpl(fiber, expirationTime, false);\n      }\n\n      function checkRootNeedsClearing(root, fiber, expirationTime) {\n        if (!isWorking && root === nextRoot && expirationTime < nextRenderExpirationTime) {\n          // Restart the root from the top.\n          if (nextUnitOfWork !== null) {\n            // This is an interruption. (Used for performance tracking.)\n            interruptedBy = fiber;\n          }\n          nextRoot = null;\n          nextUnitOfWork = null;\n          nextRenderExpirationTime = NoWork;\n        }\n      }\n\n      function scheduleWorkImpl(fiber, expirationTime, isErrorRecovery) {\n        recordScheduleUpdate();\n\n        {\n          if (!isErrorRecovery && fiber.tag === ClassComponent) {\n            var instance = fiber.stateNode;\n            warnAboutInvalidUpdates(instance);\n          }\n        }\n\n        var node = fiber;\n        while (node !== null) {\n          // Walk the parent path to the root and update each node's\n          // expiration time.\n          if (node.expirationTime === NoWork || node.expirationTime > expirationTime) {\n            node.expirationTime = expirationTime;\n          }\n          if (node.alternate !== null) {\n            if (node.alternate.expirationTime === NoWork || node.alternate.expirationTime > expirationTime) {\n              node.alternate.expirationTime = expirationTime;\n            }\n          }\n          if (node['return'] === null) {\n            if (node.tag === HostRoot) {\n              var root = node.stateNode;\n\n              checkRootNeedsClearing(root, fiber, expirationTime);\n              requestWork(root, expirationTime);\n              checkRootNeedsClearing(root, fiber, expirationTime);\n            } else {\n              {\n                if (!isErrorRecovery && fiber.tag === ClassComponent) {\n                  warnAboutUpdateOnUnmounted(fiber);\n                }\n              }\n              return;\n            }\n          }\n          node = node['return'];\n        }\n      }\n\n      function scheduleErrorRecovery(fiber) {\n        scheduleWorkImpl(fiber, Sync, true);\n      }\n\n      function recalculateCurrentTime() {\n        // Subtract initial time so it fits inside 32bits\n        var ms = now() - startTime;\n        mostRecentCurrentTime = msToExpirationTime(ms);\n        return mostRecentCurrentTime;\n      }\n\n      function deferredUpdates(fn) {\n        var previousExpirationContext = expirationContext;\n        expirationContext = computeAsyncExpiration();\n        try {\n          return fn();\n        } finally {\n          expirationContext = previousExpirationContext;\n        }\n      }\n\n      function syncUpdates(fn) {\n        var previousExpirationContext = expirationContext;\n        expirationContext = Sync;\n        try {\n          return fn();\n        } finally {\n          expirationContext = previousExpirationContext;\n        }\n      }\n\n      // TODO: Everything below this is written as if it has been lifted to the\n      // renderers. I'll do this in a follow-up.\n\n      // Linked-list of roots\n      var firstScheduledRoot = null;\n      var lastScheduledRoot = null;\n\n      var callbackExpirationTime = NoWork;\n      var callbackID = -1;\n      var isRendering = false;\n      var nextFlushedRoot = null;\n      var nextFlushedExpirationTime = NoWork;\n      var deadlineDidExpire = false;\n      var hasUnhandledError = false;\n      var unhandledError = null;\n      var deadline = null;\n\n      var isBatchingUpdates = false;\n      var isUnbatchingUpdates = false;\n\n      // Use these to prevent an infinite loop of nested updates\n      var NESTED_UPDATE_LIMIT = 1000;\n      var nestedUpdateCount = 0;\n\n      var timeHeuristicForUnitOfWork = 1;\n\n      function scheduleCallbackWithExpiration(expirationTime) {\n        if (callbackExpirationTime !== NoWork) {\n          // A callback is already scheduled. Check its expiration time (timeout).\n          if (expirationTime > callbackExpirationTime) {\n            // Existing callback has sufficient timeout. Exit.\n            return;\n          } else {\n            // Existing callback has insufficient timeout. Cancel and schedule a\n            // new one.\n            cancelDeferredCallback(callbackID);\n          }\n          // The request callback timer is already running. Don't start a new one.\n        } else {\n          startRequestCallbackTimer();\n        }\n\n        // Compute a timeout for the given expiration time.\n        var currentMs = now() - startTime;\n        var expirationMs = expirationTimeToMs(expirationTime);\n        var timeout = expirationMs - currentMs;\n\n        callbackExpirationTime = expirationTime;\n        callbackID = scheduleDeferredCallback(performAsyncWork, { timeout: timeout });\n      }\n\n      // requestWork is called by the scheduler whenever a root receives an update.\n      // It's up to the renderer to call renderRoot at some point in the future.\n      function requestWork(root, expirationTime) {\n        if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {\n          invariant(false, 'Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops.');\n        }\n\n        // Add the root to the schedule.\n        // Check if this root is already part of the schedule.\n        if (root.nextScheduledRoot === null) {\n          // This root is not already scheduled. Add it.\n          root.remainingExpirationTime = expirationTime;\n          if (lastScheduledRoot === null) {\n            firstScheduledRoot = lastScheduledRoot = root;\n            root.nextScheduledRoot = root;\n          } else {\n            lastScheduledRoot.nextScheduledRoot = root;\n            lastScheduledRoot = root;\n            lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;\n          }\n        } else {\n          // This root is already scheduled, but its priority may have increased.\n          var remainingExpirationTime = root.remainingExpirationTime;\n          if (remainingExpirationTime === NoWork || expirationTime < remainingExpirationTime) {\n            // Update the priority.\n            root.remainingExpirationTime = expirationTime;\n          }\n        }\n\n        if (isRendering) {\n          // Prevent reentrancy. Remaining work will be scheduled at the end of\n          // the currently rendering batch.\n          return;\n        }\n\n        if (isBatchingUpdates) {\n          // Flush work at the end of the batch.\n          if (isUnbatchingUpdates) {\n            // ...unless we're inside unbatchedUpdates, in which case we should\n            // flush it now.\n            nextFlushedRoot = root;\n            nextFlushedExpirationTime = Sync;\n            performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime);\n          }\n          return;\n        }\n\n        // TODO: Get rid of Sync and use current time?\n        if (expirationTime === Sync) {\n          performWork(Sync, null);\n        } else {\n          scheduleCallbackWithExpiration(expirationTime);\n        }\n      }\n\n      function findHighestPriorityRoot() {\n        var highestPriorityWork = NoWork;\n        var highestPriorityRoot = null;\n\n        if (lastScheduledRoot !== null) {\n          var previousScheduledRoot = lastScheduledRoot;\n          var root = firstScheduledRoot;\n          while (root !== null) {\n            var remainingExpirationTime = root.remainingExpirationTime;\n            if (remainingExpirationTime === NoWork) {\n              // This root no longer has work. Remove it from the scheduler.\n\n              // TODO: This check is redudant, but Flow is confused by the branch\n              // below where we set lastScheduledRoot to null, even though we break\n              // from the loop right after.\n              !(previousScheduledRoot !== null && lastScheduledRoot !== null) ? invariant(false, 'Should have a previous and last root. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n              if (root === root.nextScheduledRoot) {\n                // This is the only root in the list.\n                root.nextScheduledRoot = null;\n                firstScheduledRoot = lastScheduledRoot = null;\n                break;\n              } else if (root === firstScheduledRoot) {\n                // This is the first root in the list.\n                var next = root.nextScheduledRoot;\n                firstScheduledRoot = next;\n                lastScheduledRoot.nextScheduledRoot = next;\n                root.nextScheduledRoot = null;\n              } else if (root === lastScheduledRoot) {\n                // This is the last root in the list.\n                lastScheduledRoot = previousScheduledRoot;\n                lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;\n                root.nextScheduledRoot = null;\n                break;\n              } else {\n                previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot;\n                root.nextScheduledRoot = null;\n              }\n              root = previousScheduledRoot.nextScheduledRoot;\n            } else {\n              if (highestPriorityWork === NoWork || remainingExpirationTime < highestPriorityWork) {\n                // Update the priority, if it's higher\n                highestPriorityWork = remainingExpirationTime;\n                highestPriorityRoot = root;\n              }\n              if (root === lastScheduledRoot) {\n                break;\n              }\n              previousScheduledRoot = root;\n              root = root.nextScheduledRoot;\n            }\n          }\n        }\n\n        // If the next root is the same as the previous root, this is a nested\n        // update. To prevent an infinite loop, increment the nested update count.\n        var previousFlushedRoot = nextFlushedRoot;\n        if (previousFlushedRoot !== null && previousFlushedRoot === highestPriorityRoot) {\n          nestedUpdateCount++;\n        } else {\n          // Reset whenever we switch roots.\n          nestedUpdateCount = 0;\n        }\n        nextFlushedRoot = highestPriorityRoot;\n        nextFlushedExpirationTime = highestPriorityWork;\n      }\n\n      function performAsyncWork(dl) {\n        performWork(NoWork, dl);\n      }\n\n      function performWork(minExpirationTime, dl) {\n        deadline = dl;\n\n        // Keep working on roots until there's no more work, or until the we reach\n        // the deadline.\n        findHighestPriorityRoot();\n\n        if (enableUserTimingAPI && deadline !== null) {\n          var didExpire = nextFlushedExpirationTime < recalculateCurrentTime();\n          stopRequestCallbackTimer(didExpire);\n        }\n\n        while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || nextFlushedExpirationTime <= minExpirationTime) && !deadlineDidExpire) {\n          performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime);\n          // Find the next highest priority work.\n          findHighestPriorityRoot();\n        }\n\n        // We're done flushing work. Either we ran out of time in this callback,\n        // or there's no more work left with sufficient priority.\n\n        // If we're inside a callback, set this to false since we just completed it.\n        if (deadline !== null) {\n          callbackExpirationTime = NoWork;\n          callbackID = -1;\n        }\n        // If there's work left over, schedule a new callback.\n        if (nextFlushedExpirationTime !== NoWork) {\n          scheduleCallbackWithExpiration(nextFlushedExpirationTime);\n        }\n\n        // Clean-up.\n        deadline = null;\n        deadlineDidExpire = false;\n        nestedUpdateCount = 0;\n\n        if (hasUnhandledError) {\n          var _error4 = unhandledError;\n          unhandledError = null;\n          hasUnhandledError = false;\n          throw _error4;\n        }\n      }\n\n      function performWorkOnRoot(root, expirationTime) {\n        !!isRendering ? invariant(false, 'performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n\n        isRendering = true;\n\n        // Check if this is async work or sync/expired work.\n        // TODO: Pass current time as argument to renderRoot, commitRoot\n        if (expirationTime <= recalculateCurrentTime()) {\n          // Flush sync work.\n          var finishedWork = root.finishedWork;\n          if (finishedWork !== null) {\n            // This root is already complete. We can commit it.\n            root.finishedWork = null;\n            root.remainingExpirationTime = commitRoot(finishedWork);\n          } else {\n            root.finishedWork = null;\n            finishedWork = renderRoot(root, expirationTime);\n            if (finishedWork !== null) {\n              // We've completed the root. Commit it.\n              root.remainingExpirationTime = commitRoot(finishedWork);\n            }\n          }\n        } else {\n          // Flush async work.\n          var _finishedWork = root.finishedWork;\n          if (_finishedWork !== null) {\n            // This root is already complete. We can commit it.\n            root.finishedWork = null;\n            root.remainingExpirationTime = commitRoot(_finishedWork);\n          } else {\n            root.finishedWork = null;\n            _finishedWork = renderRoot(root, expirationTime);\n            if (_finishedWork !== null) {\n              // We've completed the root. Check the deadline one more time\n              // before committing.\n              if (!shouldYield()) {\n                // Still time left. Commit the root.\n                root.remainingExpirationTime = commitRoot(_finishedWork);\n              } else {\n                // There's no time left. Mark this root as complete. We'll come\n                // back and commit it later.\n                root.finishedWork = _finishedWork;\n              }\n            }\n          }\n        }\n\n        isRendering = false;\n      }\n\n      // When working on async work, the reconciler asks the renderer if it should\n      // yield execution. For DOM, we implement this with requestIdleCallback.\n      function shouldYield() {\n        if (deadline === null) {\n          return false;\n        }\n        if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {\n          // Disregard deadline.didTimeout. Only expired work should be flushed\n          // during a timeout. This path is only hit for non-expired work.\n          return false;\n        }\n        deadlineDidExpire = true;\n        return true;\n      }\n\n      // TODO: Not happy about this hook. Conceptually, renderRoot should return a\n      // tuple of (isReadyForCommit, didError, error)\n      function onUncaughtError(error) {\n        !(nextFlushedRoot !== null) ? invariant(false, 'Should be working on a root. This error is likely caused by a bug in React. Please file an issue.') : void 0;\n        // Unschedule this root so we don't work on it again until there's\n        // another update.\n        nextFlushedRoot.remainingExpirationTime = NoWork;\n        if (!hasUnhandledError) {\n          hasUnhandledError = true;\n          unhandledError = error;\n        }\n      }\n\n      // TODO: Batching should be implemented at the renderer level, not inside\n      // the reconciler.\n      function batchedUpdates(fn, a) {\n        var previousIsBatchingUpdates = isBatchingUpdates;\n        isBatchingUpdates = true;\n        try {\n          return fn(a);\n        } finally {\n          isBatchingUpdates = previousIsBatchingUpdates;\n          if (!isBatchingUpdates && !isRendering) {\n            performWork(Sync, null);\n          }\n        }\n      }\n\n      // TODO: Batching should be implemented at the renderer level, not inside\n      // the reconciler.\n      function unbatchedUpdates(fn) {\n        if (isBatchingUpdates && !isUnbatchingUpdates) {\n          isUnbatchingUpdates = true;\n          try {\n            return fn();\n          } finally {\n            isUnbatchingUpdates = false;\n          }\n        }\n        return fn();\n      }\n\n      // TODO: Batching should be implemented at the renderer level, not within\n      // the reconciler.\n      function flushSync(fn) {\n        var previousIsBatchingUpdates = isBatchingUpdates;\n        isBatchingUpdates = true;\n        try {\n          return syncUpdates(fn);\n        } finally {\n          isBatchingUpdates = previousIsBatchingUpdates;\n          !!isRendering ? invariant(false, 'flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering.') : void 0;\n          performWork(Sync, null);\n        }\n      }\n\n      return {\n        computeAsyncExpiration: computeAsyncExpiration,\n        computeExpirationForFiber: computeExpirationForFiber,\n        scheduleWork: scheduleWork,\n        batchedUpdates: batchedUpdates,\n        unbatchedUpdates: unbatchedUpdates,\n        flushSync: flushSync,\n        deferredUpdates: deferredUpdates\n      };\n    };\n\n    {\n      var didWarnAboutNestedUpdates = false;\n    }\n\n    // 0 is PROD, 1 is DEV.\n    // Might add PROFILE later.\n\n\n    function getContextForSubtree(parentComponent) {\n      if (!parentComponent) {\n        return emptyObject;\n      }\n\n      var fiber = get(parentComponent);\n      var parentContext = findCurrentUnmaskedContext(fiber);\n      return isContextProvider(fiber) ? processChildContext(fiber, parentContext) : parentContext;\n    }\n\n    var ReactFiberReconciler$1 = function (config) {\n      var getPublicInstance = config.getPublicInstance;\n\n      var _ReactFiberScheduler = ReactFiberScheduler(config),\n          computeAsyncExpiration = _ReactFiberScheduler.computeAsyncExpiration,\n          computeExpirationForFiber = _ReactFiberScheduler.computeExpirationForFiber,\n          scheduleWork = _ReactFiberScheduler.scheduleWork,\n          batchedUpdates = _ReactFiberScheduler.batchedUpdates,\n          unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates,\n          flushSync = _ReactFiberScheduler.flushSync,\n          deferredUpdates = _ReactFiberScheduler.deferredUpdates;\n\n      function scheduleTopLevelUpdate(current, element, callback) {\n        {\n          if (ReactDebugCurrentFiber.phase === 'render' && ReactDebugCurrentFiber.current !== null && !didWarnAboutNestedUpdates) {\n            didWarnAboutNestedUpdates = true;\n            warning(false, 'Render methods should be a pure function of props and state; ' + 'triggering nested component updates from render is not allowed. ' + 'If necessary, trigger nested updates in componentDidUpdate.\\n\\n' + 'Check the render method of %s.', getComponentName(ReactDebugCurrentFiber.current) || 'Unknown');\n          }\n        }\n\n        callback = callback === undefined ? null : callback;\n        {\n          warning(callback === null || typeof callback === 'function', 'render(...): Expected the last optional `callback` argument to be a ' + 'function. Instead received: %s.', callback);\n        }\n\n        var expirationTime = void 0;\n        // Check if the top-level element is an async wrapper component. If so,\n        // treat updates to the root as async. This is a bit weird but lets us\n        // avoid a separate `renderAsync` API.\n        if (enableAsyncSubtreeAPI && element != null && element.type != null && element.type.prototype != null && element.type.prototype.unstable_isAsyncReactComponent === true) {\n          expirationTime = computeAsyncExpiration();\n        } else {\n          expirationTime = computeExpirationForFiber(current);\n        }\n\n        var update = {\n          expirationTime: expirationTime,\n          partialState: { element: element },\n          callback: callback,\n          isReplace: false,\n          isForced: false,\n          nextCallback: null,\n          next: null\n        };\n        insertUpdateIntoFiber(current, update);\n        scheduleWork(current, expirationTime);\n      }\n\n      function findHostInstance(fiber) {\n        var hostFiber = findCurrentHostFiber(fiber);\n        if (hostFiber === null) {\n          return null;\n        }\n        return hostFiber.stateNode;\n      }\n\n      return {\n        createContainer: function (containerInfo, hydrate) {\n          return createFiberRoot(containerInfo, hydrate);\n        },\n        updateContainer: function (element, container, parentComponent, callback) {\n          // TODO: If this is a nested container, this won't be the root.\n          var current = container.current;\n\n          {\n            if (ReactFiberInstrumentation_1.debugTool) {\n              if (current.alternate === null) {\n                ReactFiberInstrumentation_1.debugTool.onMountContainer(container);\n              } else if (element === null) {\n                ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);\n              } else {\n                ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);\n              }\n            }\n          }\n\n          var context = getContextForSubtree(parentComponent);\n          if (container.context === null) {\n            container.context = context;\n          } else {\n            container.pendingContext = context;\n          }\n\n          scheduleTopLevelUpdate(current, element, callback);\n        },\n\n        batchedUpdates: batchedUpdates,\n\n        unbatchedUpdates: unbatchedUpdates,\n\n        deferredUpdates: deferredUpdates,\n\n        flushSync: flushSync,\n\n        getPublicRootInstance: function (container) {\n          var containerFiber = container.current;\n          if (!containerFiber.child) {\n            return null;\n          }\n          switch (containerFiber.child.tag) {\n            case HostComponent:\n              return getPublicInstance(containerFiber.child.stateNode);\n            default:\n              return containerFiber.child.stateNode;\n          }\n        },\n\n        findHostInstance: findHostInstance,\n\n        findHostInstanceWithNoPortals: function (fiber) {\n          var hostFiber = findCurrentHostFiberWithNoPortals(fiber);\n          if (hostFiber === null) {\n            return null;\n          }\n          return hostFiber.stateNode;\n        },\n        injectIntoDevTools: function (devToolsConfig) {\n          var findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;\n\n          return injectInternals(_assign({}, devToolsConfig, {\n            findHostInstanceByFiber: function (fiber) {\n              return findHostInstance(fiber);\n            },\n            findFiberByHostInstance: function (instance) {\n              if (!findFiberByHostInstance) {\n                // Might not be implemented by the renderer.\n                return null;\n              }\n              return findFiberByHostInstance(instance);\n            }\n          }));\n        }\n      };\n    };\n\n    var ReactFiberReconciler$2 = Object.freeze({\n      default: ReactFiberReconciler$1\n    });\n\n    var ReactFiberReconciler$3 = ReactFiberReconciler$2 && ReactFiberReconciler$1 || ReactFiberReconciler$2;\n\n    // TODO: bundle Flow types with the package.\n\n\n    // TODO: decide on the top-level export form.\n    // This is hacky but makes it work with both Rollup and Jest.\n    var reactReconciler = ReactFiberReconciler$3['default'] ? ReactFiberReconciler$3['default'] : ReactFiberReconciler$3;\n\n    function createPortal$1(children, containerInfo,\n    // TODO: figure out the API for cross-renderer implementation.\n    implementation) {\n      var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n      return {\n        // This tag allow us to uniquely identify this as a React Portal\n        $$typeof: REACT_PORTAL_TYPE,\n        key: key == null ? null : '' + key,\n        children: children,\n        containerInfo: containerInfo,\n        implementation: implementation\n      };\n    }\n\n    // TODO: this is special because it gets imported during build.\n\n    var ReactVersion = '16.2.0';\n\n    // a requestAnimationFrame, storing the time for the start of the frame, then\n    // scheduling a postMessage which gets scheduled after paint. Within the\n    // postMessage handler do as much work as possible until time + frame rate.\n    // By separating the idle call into a separate event tick we ensure that\n    // layout, paint and other browser work is counted against the available time.\n    // The frame rate is dynamically adjusted.\n\n    {\n      if (ExecutionEnvironment.canUseDOM && typeof requestAnimationFrame !== 'function') {\n        warning(false, 'React depends on requestAnimationFrame. Make sure that you load a ' + 'polyfill in older browsers. http://fb.me/react-polyfills');\n      }\n    }\n\n    var hasNativePerformanceNow = typeof performance === 'object' && typeof performance.now === 'function';\n\n    var now = void 0;\n    if (hasNativePerformanceNow) {\n      now = function () {\n        return performance.now();\n      };\n    } else {\n      now = function () {\n        return Date.now();\n      };\n    }\n\n    // TODO: There's no way to cancel, because Fiber doesn't atm.\n    var rIC = void 0;\n    var cIC = void 0;\n\n    if (!ExecutionEnvironment.canUseDOM) {\n      rIC = function (frameCallback) {\n        return setTimeout(function () {\n          frameCallback({\n            timeRemaining: function () {\n              return Infinity;\n            }\n          });\n        });\n      };\n      cIC = function (timeoutID) {\n        clearTimeout(timeoutID);\n      };\n    } else if (typeof requestIdleCallback !== 'function' || typeof cancelIdleCallback !== 'function') {\n      // Polyfill requestIdleCallback and cancelIdleCallback\n\n      var scheduledRICCallback = null;\n      var isIdleScheduled = false;\n      var timeoutTime = -1;\n\n      var isAnimationFrameScheduled = false;\n\n      var frameDeadline = 0;\n      // We start out assuming that we run at 30fps but then the heuristic tracking\n      // will adjust this value to a faster fps if we get more frequent animation\n      // frames.\n      var previousFrameTime = 33;\n      var activeFrameTime = 33;\n\n      var frameDeadlineObject;\n      if (hasNativePerformanceNow) {\n        frameDeadlineObject = {\n          didTimeout: false,\n          timeRemaining: function () {\n            // We assume that if we have a performance timer that the rAF callback\n            // gets a performance timer value. Not sure if this is always true.\n            var remaining = frameDeadline - performance.now();\n            return remaining > 0 ? remaining : 0;\n          }\n        };\n      } else {\n        frameDeadlineObject = {\n          didTimeout: false,\n          timeRemaining: function () {\n            // Fallback to Date.now()\n            var remaining = frameDeadline - Date.now();\n            return remaining > 0 ? remaining : 0;\n          }\n        };\n      }\n\n      // We use the postMessage trick to defer idle work until after the repaint.\n      var messageKey = '__reactIdleCallback$' + Math.random().toString(36).slice(2);\n      var idleTick = function (event) {\n        if (event.source !== window || event.data !== messageKey) {\n          return;\n        }\n\n        isIdleScheduled = false;\n\n        var currentTime = now();\n        if (frameDeadline - currentTime <= 0) {\n          // There's no time left in this idle period. Check if the callback has\n          // a timeout and whether it's been exceeded.\n          if (timeoutTime !== -1 && timeoutTime <= currentTime) {\n            // Exceeded the timeout. Invoke the callback even though there's no\n            // time left.\n            frameDeadlineObject.didTimeout = true;\n          } else {\n            // No timeout.\n            if (!isAnimationFrameScheduled) {\n              // Schedule another animation callback so we retry later.\n              isAnimationFrameScheduled = true;\n              requestAnimationFrame(animationTick);\n            }\n            // Exit without invoking the callback.\n            return;\n          }\n        } else {\n          // There's still time left in this idle period.\n          frameDeadlineObject.didTimeout = false;\n        }\n\n        timeoutTime = -1;\n        var callback = scheduledRICCallback;\n        scheduledRICCallback = null;\n        if (callback !== null) {\n          callback(frameDeadlineObject);\n        }\n      };\n      // Assumes that we have addEventListener in this environment. Might need\n      // something better for old IE.\n      window.addEventListener('message', idleTick, false);\n\n      var animationTick = function (rafTime) {\n        isAnimationFrameScheduled = false;\n        var nextFrameTime = rafTime - frameDeadline + activeFrameTime;\n        if (nextFrameTime < activeFrameTime && previousFrameTime < activeFrameTime) {\n          if (nextFrameTime < 8) {\n            // Defensive coding. We don't support higher frame rates than 120hz.\n            // If we get lower than that, it is probably a bug.\n            nextFrameTime = 8;\n          }\n          // If one frame goes long, then the next one can be short to catch up.\n          // If two frames are short in a row, then that's an indication that we\n          // actually have a higher frame rate than what we're currently optimizing.\n          // We adjust our heuristic dynamically accordingly. For example, if we're\n          // running on 120hz display or 90hz VR display.\n          // Take the max of the two in case one of them was an anomaly due to\n          // missed frame deadlines.\n          activeFrameTime = nextFrameTime < previousFrameTime ? previousFrameTime : nextFrameTime;\n        } else {\n          previousFrameTime = nextFrameTime;\n        }\n        frameDeadline = rafTime + activeFrameTime;\n        if (!isIdleScheduled) {\n          isIdleScheduled = true;\n          window.postMessage(messageKey, '*');\n        }\n      };\n\n      rIC = function (callback, options) {\n        // This assumes that we only schedule one callback at a time because that's\n        // how Fiber uses it.\n        scheduledRICCallback = callback;\n        if (options != null && typeof options.timeout === 'number') {\n          timeoutTime = now() + options.timeout;\n        }\n        if (!isAnimationFrameScheduled) {\n          // If rAF didn't already schedule one, we need to schedule a frame.\n          // TODO: If this rAF doesn't materialize because the browser throttles, we\n          // might want to still have setTimeout trigger rIC as a backup to ensure\n          // that we keep performing work.\n          isAnimationFrameScheduled = true;\n          requestAnimationFrame(animationTick);\n        }\n        return 0;\n      };\n\n      cIC = function () {\n        scheduledRICCallback = null;\n        isIdleScheduled = false;\n        timeoutTime = -1;\n      };\n    } else {\n      rIC = window.requestIdleCallback;\n      cIC = window.cancelIdleCallback;\n    }\n\n    /**\n     * Forked from fbjs/warning:\n     * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js\n     *\n     * Only change is we use console.warn instead of console.error,\n     * and do nothing when 'console' is not supported.\n     * This really simplifies the code.\n     * ---\n     * Similar to invariant but only logs a warning if the condition is not met.\n     * This can be used to log issues in development environments in critical\n     * paths. Removing the logging code for production environments will keep the\n     * same logic and follow the same code paths.\n     */\n\n    var lowPriorityWarning = function () {};\n\n    {\n      var printWarning = function (format) {\n        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n          args[_key - 1] = arguments[_key];\n        }\n\n        var argIndex = 0;\n        var message = 'Warning: ' + format.replace(/%s/g, function () {\n          return args[argIndex++];\n        });\n        if (typeof console !== 'undefined') {\n          console.warn(message);\n        }\n        try {\n          // --- Welcome to debugging React ---\n          // This error was thrown as a convenience so that you can use this stack\n          // to find the callsite that caused this warning to fire.\n          throw new Error(message);\n        } catch (x) {}\n      };\n\n      lowPriorityWarning = function (condition, format) {\n        if (format === undefined) {\n          throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');\n        }\n        if (!condition) {\n          for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {\n            args[_key2 - 2] = arguments[_key2];\n          }\n\n          printWarning.apply(undefined, [format].concat(args));\n        }\n      };\n    }\n\n    var lowPriorityWarning$1 = lowPriorityWarning;\n\n    // isAttributeNameSafe() is currently duplicated in DOMMarkupOperations.\n    // TODO: Find a better place for this.\n    var VALID_ATTRIBUTE_NAME_REGEX = new RegExp('^[' + ATTRIBUTE_NAME_START_CHAR + '][' + ATTRIBUTE_NAME_CHAR + ']*$');\n    var illegalAttributeNameCache = {};\n    var validatedAttributeNameCache = {};\n    function isAttributeNameSafe(attributeName) {\n      if (validatedAttributeNameCache.hasOwnProperty(attributeName)) {\n        return true;\n      }\n      if (illegalAttributeNameCache.hasOwnProperty(attributeName)) {\n        return false;\n      }\n      if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) {\n        validatedAttributeNameCache[attributeName] = true;\n        return true;\n      }\n      illegalAttributeNameCache[attributeName] = true;\n      {\n        warning(false, 'Invalid attribute name: `%s`', attributeName);\n      }\n      return false;\n    }\n\n    // shouldIgnoreValue() is currently duplicated in DOMMarkupOperations.\n    // TODO: Find a better place for this.\n    function shouldIgnoreValue(propertyInfo, value) {\n      return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false;\n    }\n\n    /**\n     * Operations for dealing with DOM properties.\n     */\n\n    /**\n     * Get the value for a property on a node. Only used in DEV for SSR validation.\n     * The \"expected\" argument is used as a hint of what the expected value is.\n     * Some properties have multiple equivalent values.\n     */\n    function getValueForProperty(node, name, expected) {\n      {\n        var propertyInfo = getPropertyInfo(name);\n        if (propertyInfo) {\n          var mutationMethod = propertyInfo.mutationMethod;\n          if (mutationMethod || propertyInfo.mustUseProperty) {\n            return node[propertyInfo.propertyName];\n          } else {\n            var attributeName = propertyInfo.attributeName;\n\n            var stringValue = null;\n\n            if (propertyInfo.hasOverloadedBooleanValue) {\n              if (node.hasAttribute(attributeName)) {\n                var value = node.getAttribute(attributeName);\n                if (value === '') {\n                  return true;\n                }\n                if (shouldIgnoreValue(propertyInfo, expected)) {\n                  return value;\n                }\n                if (value === '' + expected) {\n                  return expected;\n                }\n                return value;\n              }\n            } else if (node.hasAttribute(attributeName)) {\n              if (shouldIgnoreValue(propertyInfo, expected)) {\n                // We had an attribute but shouldn't have had one, so read it\n                // for the error message.\n                return node.getAttribute(attributeName);\n              }\n              if (propertyInfo.hasBooleanValue) {\n                // If this was a boolean, it doesn't matter what the value is\n                // the fact that we have it is the same as the expected.\n                return expected;\n              }\n              // Even if this property uses a namespace we use getAttribute\n              // because we assume its namespaced name is the same as our config.\n              // To use getAttributeNS we need the local name which we don't have\n              // in our config atm.\n              stringValue = node.getAttribute(attributeName);\n            }\n\n            if (shouldIgnoreValue(propertyInfo, expected)) {\n              return stringValue === null ? expected : stringValue;\n            } else if (stringValue === '' + expected) {\n              return expected;\n            } else {\n              return stringValue;\n            }\n          }\n        }\n      }\n    }\n\n    /**\n     * Get the value for a attribute on a node. Only used in DEV for SSR validation.\n     * The third argument is used as a hint of what the expected value is. Some\n     * attributes have multiple equivalent values.\n     */\n    function getValueForAttribute(node, name, expected) {\n      {\n        if (!isAttributeNameSafe(name)) {\n          return;\n        }\n        if (!node.hasAttribute(name)) {\n          return expected === undefined ? undefined : null;\n        }\n        var value = node.getAttribute(name);\n        if (value === '' + expected) {\n          return expected;\n        }\n        return value;\n      }\n    }\n\n    /**\n     * Sets the value for a property on a node.\n     *\n     * @param {DOMElement} node\n     * @param {string} name\n     * @param {*} value\n     */\n    function setValueForProperty(node, name, value) {\n      var propertyInfo = getPropertyInfo(name);\n\n      if (propertyInfo && shouldSetAttribute(name, value)) {\n        var mutationMethod = propertyInfo.mutationMethod;\n        if (mutationMethod) {\n          mutationMethod(node, value);\n        } else if (shouldIgnoreValue(propertyInfo, value)) {\n          deleteValueForProperty(node, name);\n          return;\n        } else if (propertyInfo.mustUseProperty) {\n          // Contrary to `setAttribute`, object properties are properly\n          // `toString`ed by IE8/9.\n          node[propertyInfo.propertyName] = value;\n        } else {\n          var attributeName = propertyInfo.attributeName;\n          var namespace = propertyInfo.attributeNamespace;\n          // `setAttribute` with objects becomes only `[object]` in IE8/9,\n          // ('' + value) makes it output the correct toString()-value.\n          if (namespace) {\n            node.setAttributeNS(namespace, attributeName, '' + value);\n          } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) {\n            node.setAttribute(attributeName, '');\n          } else {\n            node.setAttribute(attributeName, '' + value);\n          }\n        }\n      } else {\n        setValueForAttribute(node, name, shouldSetAttribute(name, value) ? value : null);\n        return;\n      }\n\n      {}\n    }\n\n    function setValueForAttribute(node, name, value) {\n      if (!isAttributeNameSafe(name)) {\n        return;\n      }\n      if (value == null) {\n        node.removeAttribute(name);\n      } else {\n        node.setAttribute(name, '' + value);\n      }\n\n      {}\n    }\n\n    /**\n     * Deletes an attributes from a node.\n     *\n     * @param {DOMElement} node\n     * @param {string} name\n     */\n    function deleteValueForAttribute(node, name) {\n      node.removeAttribute(name);\n    }\n\n    /**\n     * Deletes the value for a property on a node.\n     *\n     * @param {DOMElement} node\n     * @param {string} name\n     */\n    function deleteValueForProperty(node, name) {\n      var propertyInfo = getPropertyInfo(name);\n      if (propertyInfo) {\n        var mutationMethod = propertyInfo.mutationMethod;\n        if (mutationMethod) {\n          mutationMethod(node, undefined);\n        } else if (propertyInfo.mustUseProperty) {\n          var propName = propertyInfo.propertyName;\n          if (propertyInfo.hasBooleanValue) {\n            node[propName] = false;\n          } else {\n            node[propName] = '';\n          }\n        } else {\n          node.removeAttribute(propertyInfo.attributeName);\n        }\n      } else {\n        node.removeAttribute(name);\n      }\n    }\n\n    var ReactControlledValuePropTypes = {\n      checkPropTypes: null\n    };\n\n    {\n      var hasReadOnlyValue = {\n        button: true,\n        checkbox: true,\n        image: true,\n        hidden: true,\n        radio: true,\n        reset: true,\n        submit: true\n      };\n\n      var propTypes = {\n        value: function (props, propName, componentName) {\n          if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) {\n            return null;\n          }\n          return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.');\n        },\n        checked: function (props, propName, componentName) {\n          if (!props[propName] || props.onChange || props.readOnly || props.disabled) {\n            return null;\n          }\n          return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.');\n        }\n      };\n\n      /**\n       * Provide a linked `value` attribute for controlled forms. You should not use\n       * this outside of the ReactDOM controlled form components.\n       */\n      ReactControlledValuePropTypes.checkPropTypes = function (tagName, props, getStack) {\n        checkPropTypes(propTypes, props, 'prop', tagName, getStack);\n      };\n    }\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var getCurrentFiberOwnerName$2 = ReactDebugCurrentFiber.getCurrentFiberOwnerName;\n    var getCurrentFiberStackAddendum$3 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    var didWarnValueDefaultValue = false;\n    var didWarnCheckedDefaultChecked = false;\n    var didWarnControlledToUncontrolled = false;\n    var didWarnUncontrolledToControlled = false;\n\n    function isControlled(props) {\n      var usesChecked = props.type === 'checkbox' || props.type === 'radio';\n      return usesChecked ? props.checked != null : props.value != null;\n    }\n\n    /**\n     * Implements an <input> host component that allows setting these optional\n     * props: `checked`, `value`, `defaultChecked`, and `defaultValue`.\n     *\n     * If `checked` or `value` are not supplied (or null/undefined), user actions\n     * that affect the checked state or value will trigger updates to the element.\n     *\n     * If they are supplied (and not null/undefined), the rendered element will not\n     * trigger updates to the element. Instead, the props must change in order for\n     * the rendered element to be updated.\n     *\n     * The rendered element will be initialized as unchecked (or `defaultChecked`)\n     * with an empty value (or `defaultValue`).\n     *\n     * See http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html\n     */\n\n    function getHostProps(element, props) {\n      var node = element;\n      var value = props.value;\n      var checked = props.checked;\n\n      var hostProps = _assign({\n        // Make sure we set .type before any other properties (setting .value\n        // before .type means .value is lost in IE11 and below)\n        type: undefined,\n        // Make sure we set .step before .value (setting .value before .step\n        // means .value is rounded on mount, based upon step precision)\n        step: undefined,\n        // Make sure we set .min & .max before .value (to ensure proper order\n        // in corner cases such as min or max deriving from value, e.g. Issue #7170)\n        min: undefined,\n        max: undefined\n      }, props, {\n        defaultChecked: undefined,\n        defaultValue: undefined,\n        value: value != null ? value : node._wrapperState.initialValue,\n        checked: checked != null ? checked : node._wrapperState.initialChecked\n      });\n\n      return hostProps;\n    }\n\n    function initWrapperState(element, props) {\n      {\n        ReactControlledValuePropTypes.checkPropTypes('input', props, getCurrentFiberStackAddendum$3);\n\n        if (props.checked !== undefined && props.defaultChecked !== undefined && !didWarnCheckedDefaultChecked) {\n          warning(false, '%s contains an input of type %s with both checked and defaultChecked props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the checked prop, or the defaultChecked prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', getCurrentFiberOwnerName$2() || 'A component', props.type);\n          didWarnCheckedDefaultChecked = true;\n        }\n        if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue) {\n          warning(false, '%s contains an input of type %s with both value and defaultValue props. ' + 'Input elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled input ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components', getCurrentFiberOwnerName$2() || 'A component', props.type);\n          didWarnValueDefaultValue = true;\n        }\n      }\n\n      var defaultValue = props.defaultValue;\n      var node = element;\n      node._wrapperState = {\n        initialChecked: props.checked != null ? props.checked : props.defaultChecked,\n        initialValue: props.value != null ? props.value : defaultValue,\n        controlled: isControlled(props)\n      };\n    }\n\n    function updateChecked(element, props) {\n      var node = element;\n      var checked = props.checked;\n      if (checked != null) {\n        setValueForProperty(node, 'checked', checked);\n      }\n    }\n\n    function updateWrapper(element, props) {\n      var node = element;\n      {\n        var controlled = isControlled(props);\n\n        if (!node._wrapperState.controlled && controlled && !didWarnUncontrolledToControlled) {\n          warning(false, 'A component is changing an uncontrolled input of type %s to be controlled. ' + 'Input elements should not switch from uncontrolled to controlled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s', props.type, getCurrentFiberStackAddendum$3());\n          didWarnUncontrolledToControlled = true;\n        }\n        if (node._wrapperState.controlled && !controlled && !didWarnControlledToUncontrolled) {\n          warning(false, 'A component is changing a controlled input of type %s to be uncontrolled. ' + 'Input elements should not switch from controlled to uncontrolled (or vice versa). ' + 'Decide between using a controlled or uncontrolled input ' + 'element for the lifetime of the component. More info: https://fb.me/react-controlled-components%s', props.type, getCurrentFiberStackAddendum$3());\n          didWarnControlledToUncontrolled = true;\n        }\n      }\n\n      updateChecked(element, props);\n\n      var value = props.value;\n      if (value != null) {\n        if (value === 0 && node.value === '') {\n          node.value = '0';\n          // Note: IE9 reports a number inputs as 'text', so check props instead.\n        } else if (props.type === 'number') {\n          // Simulate `input.valueAsNumber`. IE9 does not support it\n          var valueAsNumber = parseFloat(node.value) || 0;\n\n          if (\n          // eslint-disable-next-line\n          value != valueAsNumber ||\n          // eslint-disable-next-line\n          value == valueAsNumber && node.value != value) {\n            // Cast `value` to a string to ensure the value is set correctly. While\n            // browsers typically do this as necessary, jsdom doesn't.\n            node.value = '' + value;\n          }\n        } else if (node.value !== '' + value) {\n          // Cast `value` to a string to ensure the value is set correctly. While\n          // browsers typically do this as necessary, jsdom doesn't.\n          node.value = '' + value;\n        }\n      } else {\n        if (props.value == null && props.defaultValue != null) {\n          // In Chrome, assigning defaultValue to certain input types triggers input validation.\n          // For number inputs, the display value loses trailing decimal points. For email inputs,\n          // Chrome raises \"The specified value <x> is not a valid email address\".\n          //\n          // Here we check to see if the defaultValue has actually changed, avoiding these problems\n          // when the user is inputting text\n          //\n          // https://github.com/facebook/react/issues/7253\n          if (node.defaultValue !== '' + props.defaultValue) {\n            node.defaultValue = '' + props.defaultValue;\n          }\n        }\n        if (props.checked == null && props.defaultChecked != null) {\n          node.defaultChecked = !!props.defaultChecked;\n        }\n      }\n    }\n\n    function postMountWrapper(element, props) {\n      var node = element;\n\n      // Detach value from defaultValue. We won't do anything if we're working on\n      // submit or reset inputs as those values & defaultValues are linked. They\n      // are not resetable nodes so this operation doesn't matter and actually\n      // removes browser-default values (eg \"Submit Query\") when no value is\n      // provided.\n\n      switch (props.type) {\n        case 'submit':\n        case 'reset':\n          break;\n        case 'color':\n        case 'date':\n        case 'datetime':\n        case 'datetime-local':\n        case 'month':\n        case 'time':\n        case 'week':\n          // This fixes the no-show issue on iOS Safari and Android Chrome:\n          // https://github.com/facebook/react/issues/7233\n          node.value = '';\n          node.value = node.defaultValue;\n          break;\n        default:\n          node.value = node.value;\n          break;\n      }\n\n      // Normally, we'd just do `node.checked = node.checked` upon initial mount, less this bug\n      // this is needed to work around a chrome bug where setting defaultChecked\n      // will sometimes influence the value of checked (even after detachment).\n      // Reference: https://bugs.chromium.org/p/chromium/issues/detail?id=608416\n      // We need to temporarily unset name to avoid disrupting radio button groups.\n      var name = node.name;\n      if (name !== '') {\n        node.name = '';\n      }\n      node.defaultChecked = !node.defaultChecked;\n      node.defaultChecked = !node.defaultChecked;\n      if (name !== '') {\n        node.name = name;\n      }\n    }\n\n    function restoreControlledState$1(element, props) {\n      var node = element;\n      updateWrapper(node, props);\n      updateNamedCousins(node, props);\n    }\n\n    function updateNamedCousins(rootNode, props) {\n      var name = props.name;\n      if (props.type === 'radio' && name != null) {\n        var queryRoot = rootNode;\n\n        while (queryRoot.parentNode) {\n          queryRoot = queryRoot.parentNode;\n        }\n\n        // If `rootNode.form` was non-null, then we could try `form.elements`,\n        // but that sometimes behaves strangely in IE8. We could also try using\n        // `form.getElementsByName`, but that will only return direct children\n        // and won't include inputs that use the HTML5 `form=` attribute. Since\n        // the input might not even be in a form. It might not even be in the\n        // document. Let's just use the local `querySelectorAll` to ensure we don't\n        // miss anything.\n        var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type=\"radio\"]');\n\n        for (var i = 0; i < group.length; i++) {\n          var otherNode = group[i];\n          if (otherNode === rootNode || otherNode.form !== rootNode.form) {\n            continue;\n          }\n          // This will throw if radio buttons rendered by different copies of React\n          // and the same name are rendered into the same form (same as #1939).\n          // That's probably okay; we don't support it just as we don't support\n          // mixing React radio buttons with non-React ones.\n          var otherProps = getFiberCurrentPropsFromNode$1(otherNode);\n          !otherProps ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : void 0;\n\n          // We need update the tracked value on the named cousin since the value\n          // was changed but the input saw no event or value set\n          updateValueIfChanged(otherNode);\n\n          // If this is a controlled radio button group, forcing the input that\n          // was previously checked to update will cause it to be come re-checked\n          // as appropriate.\n          updateWrapper(otherNode, otherProps);\n        }\n      }\n    }\n\n    function flattenChildren(children) {\n      var content = '';\n\n      // Flatten children and warn if they aren't strings or numbers;\n      // invalid types are ignored.\n      // We can silently skip them because invalid DOM nesting warning\n      // catches these cases in Fiber.\n      React.Children.forEach(children, function (child) {\n        if (child == null) {\n          return;\n        }\n        if (typeof child === 'string' || typeof child === 'number') {\n          content += child;\n        }\n      });\n\n      return content;\n    }\n\n    /**\n     * Implements an <option> host component that warns when `selected` is set.\n     */\n\n    function validateProps(element, props) {\n      // TODO (yungsters): Remove support for `selected` in <option>.\n      {\n        warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.');\n      }\n    }\n\n    function postMountWrapper$1(element, props) {\n      // value=\"\" should make a value attribute (#6219)\n      if (props.value != null) {\n        element.setAttribute('value', props.value);\n      }\n    }\n\n    function getHostProps$1(element, props) {\n      var hostProps = _assign({ children: undefined }, props);\n      var content = flattenChildren(props.children);\n\n      if (content) {\n        hostProps.children = content;\n      }\n\n      return hostProps;\n    }\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var getCurrentFiberOwnerName$3 = ReactDebugCurrentFiber.getCurrentFiberOwnerName;\n    var getCurrentFiberStackAddendum$4 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    {\n      var didWarnValueDefaultValue$1 = false;\n    }\n\n    function getDeclarationErrorAddendum() {\n      var ownerName = getCurrentFiberOwnerName$3();\n      if (ownerName) {\n        return '\\n\\nCheck the render method of `' + ownerName + '`.';\n      }\n      return '';\n    }\n\n    var valuePropNames = ['value', 'defaultValue'];\n\n    /**\n     * Validation function for `value` and `defaultValue`.\n     */\n    function checkSelectPropTypes(props) {\n      ReactControlledValuePropTypes.checkPropTypes('select', props, getCurrentFiberStackAddendum$4);\n\n      for (var i = 0; i < valuePropNames.length; i++) {\n        var propName = valuePropNames[i];\n        if (props[propName] == null) {\n          continue;\n        }\n        var isArray = Array.isArray(props[propName]);\n        if (props.multiple && !isArray) {\n          warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum());\n        } else if (!props.multiple && isArray) {\n          warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum());\n        }\n      }\n    }\n\n    function updateOptions(node, multiple, propValue, setDefaultSelected) {\n      var options = node.options;\n\n      if (multiple) {\n        var selectedValues = propValue;\n        var selectedValue = {};\n        for (var i = 0; i < selectedValues.length; i++) {\n          // Prefix to avoid chaos with special keys.\n          selectedValue['$' + selectedValues[i]] = true;\n        }\n        for (var _i = 0; _i < options.length; _i++) {\n          var selected = selectedValue.hasOwnProperty('$' + options[_i].value);\n          if (options[_i].selected !== selected) {\n            options[_i].selected = selected;\n          }\n          if (selected && setDefaultSelected) {\n            options[_i].defaultSelected = true;\n          }\n        }\n      } else {\n        // Do not set `select.value` as exact behavior isn't consistent across all\n        // browsers for all cases.\n        var _selectedValue = '' + propValue;\n        var defaultSelected = null;\n        for (var _i2 = 0; _i2 < options.length; _i2++) {\n          if (options[_i2].value === _selectedValue) {\n            options[_i2].selected = true;\n            if (setDefaultSelected) {\n              options[_i2].defaultSelected = true;\n            }\n            return;\n          }\n          if (defaultSelected === null && !options[_i2].disabled) {\n            defaultSelected = options[_i2];\n          }\n        }\n        if (defaultSelected !== null) {\n          defaultSelected.selected = true;\n        }\n      }\n    }\n\n    /**\n     * Implements a <select> host component that allows optionally setting the\n     * props `value` and `defaultValue`. If `multiple` is false, the prop must be a\n     * stringable. If `multiple` is true, the prop must be an array of stringables.\n     *\n     * If `value` is not supplied (or null/undefined), user actions that change the\n     * selected option will trigger updates to the rendered options.\n     *\n     * If it is supplied (and not null/undefined), the rendered options will not\n     * update in response to user actions. Instead, the `value` prop must change in\n     * order for the rendered options to update.\n     *\n     * If `defaultValue` is provided, any options with the supplied values will be\n     * selected.\n     */\n\n    function getHostProps$2(element, props) {\n      return _assign({}, props, {\n        value: undefined\n      });\n    }\n\n    function initWrapperState$1(element, props) {\n      var node = element;\n      {\n        checkSelectPropTypes(props);\n      }\n\n      var value = props.value;\n      node._wrapperState = {\n        initialValue: value != null ? value : props.defaultValue,\n        wasMultiple: !!props.multiple\n      };\n\n      {\n        if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValueDefaultValue$1) {\n          warning(false, 'Select elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled select ' + 'element and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components');\n          didWarnValueDefaultValue$1 = true;\n        }\n      }\n    }\n\n    function postMountWrapper$2(element, props) {\n      var node = element;\n      node.multiple = !!props.multiple;\n      var value = props.value;\n      if (value != null) {\n        updateOptions(node, !!props.multiple, value, false);\n      } else if (props.defaultValue != null) {\n        updateOptions(node, !!props.multiple, props.defaultValue, true);\n      }\n    }\n\n    function postUpdateWrapper(element, props) {\n      var node = element;\n      // After the initial mount, we control selected-ness manually so don't pass\n      // this value down\n      node._wrapperState.initialValue = undefined;\n\n      var wasMultiple = node._wrapperState.wasMultiple;\n      node._wrapperState.wasMultiple = !!props.multiple;\n\n      var value = props.value;\n      if (value != null) {\n        updateOptions(node, !!props.multiple, value, false);\n      } else if (wasMultiple !== !!props.multiple) {\n        // For simplicity, reapply `defaultValue` if `multiple` is toggled.\n        if (props.defaultValue != null) {\n          updateOptions(node, !!props.multiple, props.defaultValue, true);\n        } else {\n          // Revert the select back to its default unselected state.\n          updateOptions(node, !!props.multiple, props.multiple ? [] : '', false);\n        }\n      }\n    }\n\n    function restoreControlledState$2(element, props) {\n      var node = element;\n      var value = props.value;\n\n      if (value != null) {\n        updateOptions(node, !!props.multiple, value, false);\n      }\n    }\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var getCurrentFiberStackAddendum$5 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    var didWarnValDefaultVal = false;\n\n    /**\n     * Implements a <textarea> host component that allows setting `value`, and\n     * `defaultValue`. This differs from the traditional DOM API because value is\n     * usually set as PCDATA children.\n     *\n     * If `value` is not supplied (or null/undefined), user actions that affect the\n     * value will trigger updates to the element.\n     *\n     * If `value` is supplied (and not null/undefined), the rendered element will\n     * not trigger updates to the element. Instead, the `value` prop must change in\n     * order for the rendered element to be updated.\n     *\n     * The rendered element will be initialized with an empty value, the prop\n     * `defaultValue` if specified, or the children content (deprecated).\n     */\n\n    function getHostProps$3(element, props) {\n      var node = element;\n      !(props.dangerouslySetInnerHTML == null) ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : void 0;\n\n      // Always set children to the same thing. In IE9, the selection range will\n      // get reset if `textContent` is mutated.  We could add a check in setTextContent\n      // to only set the value if/when the value differs from the node value (which would\n      // completely solve this IE9 bug), but Sebastian+Sophie seemed to like this\n      // solution. The value can be a boolean or object so that's why it's forced\n      // to be a string.\n      var hostProps = _assign({}, props, {\n        value: undefined,\n        defaultValue: undefined,\n        children: '' + node._wrapperState.initialValue\n      });\n\n      return hostProps;\n    }\n\n    function initWrapperState$2(element, props) {\n      var node = element;\n      {\n        ReactControlledValuePropTypes.checkPropTypes('textarea', props, getCurrentFiberStackAddendum$5);\n        if (props.value !== undefined && props.defaultValue !== undefined && !didWarnValDefaultVal) {\n          warning(false, 'Textarea elements must be either controlled or uncontrolled ' + '(specify either the value prop, or the defaultValue prop, but not ' + 'both). Decide between using a controlled or uncontrolled textarea ' + 'and remove one of these props. More info: ' + 'https://fb.me/react-controlled-components');\n          didWarnValDefaultVal = true;\n        }\n      }\n\n      var initialValue = props.value;\n\n      // Only bother fetching default value if we're going to use it\n      if (initialValue == null) {\n        var defaultValue = props.defaultValue;\n        // TODO (yungsters): Remove support for children content in <textarea>.\n        var children = props.children;\n        if (children != null) {\n          {\n            warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.');\n          }\n          !(defaultValue == null) ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : void 0;\n          if (Array.isArray(children)) {\n            !(children.length <= 1) ? invariant(false, '<textarea> can only have at most one child.') : void 0;\n            children = children[0];\n          }\n\n          defaultValue = '' + children;\n        }\n        if (defaultValue == null) {\n          defaultValue = '';\n        }\n        initialValue = defaultValue;\n      }\n\n      node._wrapperState = {\n        initialValue: '' + initialValue\n      };\n    }\n\n    function updateWrapper$1(element, props) {\n      var node = element;\n      var value = props.value;\n      if (value != null) {\n        // Cast `value` to a string to ensure the value is set correctly. While\n        // browsers typically do this as necessary, jsdom doesn't.\n        var newValue = '' + value;\n\n        // To avoid side effects (such as losing text selection), only set value if changed\n        if (newValue !== node.value) {\n          node.value = newValue;\n        }\n        if (props.defaultValue == null) {\n          node.defaultValue = newValue;\n        }\n      }\n      if (props.defaultValue != null) {\n        node.defaultValue = props.defaultValue;\n      }\n    }\n\n    function postMountWrapper$3(element, props) {\n      var node = element;\n      // This is in postMount because we need access to the DOM node, which is not\n      // available until after the component has mounted.\n      var textContent = node.textContent;\n\n      // Only set node.value if textContent is equal to the expected\n      // initial value. In IE10/IE11 there is a bug where the placeholder attribute\n      // will populate textContent as well.\n      // https://developer.microsoft.com/microsoft-edge/platform/issues/101525/\n      if (textContent === node._wrapperState.initialValue) {\n        node.value = textContent;\n      }\n    }\n\n    function restoreControlledState$3(element, props) {\n      // DOM component is still mounted; update\n      updateWrapper$1(element, props);\n    }\n\n    var HTML_NAMESPACE$1 = 'http://www.w3.org/1999/xhtml';\n    var MATH_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';\n    var SVG_NAMESPACE = 'http://www.w3.org/2000/svg';\n\n    var Namespaces = {\n      html: HTML_NAMESPACE$1,\n      mathml: MATH_NAMESPACE,\n      svg: SVG_NAMESPACE\n    };\n\n    // Assumes there is no parent namespace.\n    function getIntrinsicNamespace(type) {\n      switch (type) {\n        case 'svg':\n          return SVG_NAMESPACE;\n        case 'math':\n          return MATH_NAMESPACE;\n        default:\n          return HTML_NAMESPACE$1;\n      }\n    }\n\n    function getChildNamespace(parentNamespace, type) {\n      if (parentNamespace == null || parentNamespace === HTML_NAMESPACE$1) {\n        // No (or default) parent namespace: potential entry point.\n        return getIntrinsicNamespace(type);\n      }\n      if (parentNamespace === SVG_NAMESPACE && type === 'foreignObject') {\n        // We're leaving SVG.\n        return HTML_NAMESPACE$1;\n      }\n      // By default, pass namespace below.\n      return parentNamespace;\n    }\n\n    /* globals MSApp */\n\n    /**\n     * Create a function which has 'unsafe' privileges (required by windows8 apps)\n     */\n    var createMicrosoftUnsafeLocalFunction = function (func) {\n      if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {\n        return function (arg0, arg1, arg2, arg3) {\n          MSApp.execUnsafeLocalFunction(function () {\n            return func(arg0, arg1, arg2, arg3);\n          });\n        };\n      } else {\n        return func;\n      }\n    };\n\n    // SVG temp container for IE lacking innerHTML\n    var reusableSVGContainer = void 0;\n\n    /**\n     * Set the innerHTML property of a node\n     *\n     * @param {DOMElement} node\n     * @param {string} html\n     * @internal\n     */\n    var setInnerHTML = createMicrosoftUnsafeLocalFunction(function (node, html) {\n      // IE does not have innerHTML for SVG nodes, so instead we inject the\n      // new markup in a temp node and then move the child nodes across into\n      // the target node\n\n      if (node.namespaceURI === Namespaces.svg && !('innerHTML' in node)) {\n        reusableSVGContainer = reusableSVGContainer || document.createElement('div');\n        reusableSVGContainer.innerHTML = '<svg>' + html + '</svg>';\n        var svgNode = reusableSVGContainer.firstChild;\n        while (node.firstChild) {\n          node.removeChild(node.firstChild);\n        }\n        while (svgNode.firstChild) {\n          node.appendChild(svgNode.firstChild);\n        }\n      } else {\n        node.innerHTML = html;\n      }\n    });\n\n    /**\n     * Set the textContent property of a node, ensuring that whitespace is preserved\n     * even in IE8. innerText is a poor substitute for textContent and, among many\n     * issues, inserts <br> instead of the literal newline chars. innerHTML behaves\n     * as it should.\n     *\n     * @param {DOMElement} node\n     * @param {string} text\n     * @internal\n     */\n    var setTextContent = function (node, text) {\n      if (text) {\n        var firstChild = node.firstChild;\n\n        if (firstChild && firstChild === node.lastChild && firstChild.nodeType === TEXT_NODE) {\n          firstChild.nodeValue = text;\n          return;\n        }\n      }\n      node.textContent = text;\n    };\n\n    /**\n     * CSS properties which accept numbers but are not in units of \"px\".\n     */\n    var isUnitlessNumber = {\n      animationIterationCount: true,\n      borderImageOutset: true,\n      borderImageSlice: true,\n      borderImageWidth: true,\n      boxFlex: true,\n      boxFlexGroup: true,\n      boxOrdinalGroup: true,\n      columnCount: true,\n      columns: true,\n      flex: true,\n      flexGrow: true,\n      flexPositive: true,\n      flexShrink: true,\n      flexNegative: true,\n      flexOrder: true,\n      gridRow: true,\n      gridRowEnd: true,\n      gridRowSpan: true,\n      gridRowStart: true,\n      gridColumn: true,\n      gridColumnEnd: true,\n      gridColumnSpan: true,\n      gridColumnStart: true,\n      fontWeight: true,\n      lineClamp: true,\n      lineHeight: true,\n      opacity: true,\n      order: true,\n      orphans: true,\n      tabSize: true,\n      widows: true,\n      zIndex: true,\n      zoom: true,\n\n      // SVG-related properties\n      fillOpacity: true,\n      floodOpacity: true,\n      stopOpacity: true,\n      strokeDasharray: true,\n      strokeDashoffset: true,\n      strokeMiterlimit: true,\n      strokeOpacity: true,\n      strokeWidth: true\n    };\n\n    /**\n     * @param {string} prefix vendor-specific prefix, eg: Webkit\n     * @param {string} key style name, eg: transitionDuration\n     * @return {string} style name prefixed with `prefix`, properly camelCased, eg:\n     * WebkitTransitionDuration\n     */\n    function prefixKey(prefix, key) {\n      return prefix + key.charAt(0).toUpperCase() + key.substring(1);\n    }\n\n    /**\n     * Support style names that may come passed in prefixed by adding permutations\n     * of vendor prefixes.\n     */\n    var prefixes = ['Webkit', 'ms', 'Moz', 'O'];\n\n    // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an\n    // infinite loop, because it iterates over the newly added props too.\n    Object.keys(isUnitlessNumber).forEach(function (prop) {\n      prefixes.forEach(function (prefix) {\n        isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];\n      });\n    });\n\n    /**\n     * Convert a value into the proper css writable value. The style name `name`\n     * should be logical (no hyphens), as specified\n     * in `CSSProperty.isUnitlessNumber`.\n     *\n     * @param {string} name CSS property name such as `topMargin`.\n     * @param {*} value CSS property value such as `10px`.\n     * @return {string} Normalized style value with dimensions applied.\n     */\n    function dangerousStyleValue(name, value, isCustomProperty) {\n      // Note that we've removed escapeTextForBrowser() calls here since the\n      // whole string will be escaped when the attribute is injected into\n      // the markup. If you provide unsafe user data here they can inject\n      // arbitrary CSS which may be problematic (I couldn't repro this):\n      // https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet\n      // http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/\n      // This is not an XSS hole but instead a potential CSS injection issue\n      // which has lead to a greater discussion about how we're going to\n      // trust URLs moving forward. See #2115901\n\n      var isEmpty = value == null || typeof value === 'boolean' || value === '';\n      if (isEmpty) {\n        return '';\n      }\n\n      if (!isCustomProperty && typeof value === 'number' && value !== 0 && !(isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name])) {\n        return value + 'px'; // Presumes implicit 'px' suffix for unitless numbers\n      }\n\n      return ('' + value).trim();\n    }\n\n    var warnValidStyle = emptyFunction;\n\n    {\n      // 'msTransform' is correct, but the other prefixes should be capitalized\n      var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/;\n\n      // style values shouldn't contain a semicolon\n      var badStyleValueWithSemicolonPattern = /;\\s*$/;\n\n      var warnedStyleNames = {};\n      var warnedStyleValues = {};\n      var warnedForNaNValue = false;\n      var warnedForInfinityValue = false;\n\n      var warnHyphenatedStyleName = function (name, getStack) {\n        if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n          return;\n        }\n\n        warnedStyleNames[name] = true;\n        warning(false, 'Unsupported style property %s. Did you mean %s?%s', name, camelizeStyleName(name), getStack());\n      };\n\n      var warnBadVendoredStyleName = function (name, getStack) {\n        if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {\n          return;\n        }\n\n        warnedStyleNames[name] = true;\n        warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?%s', name, name.charAt(0).toUpperCase() + name.slice(1), getStack());\n      };\n\n      var warnStyleValueWithSemicolon = function (name, value, getStack) {\n        if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {\n          return;\n        }\n\n        warnedStyleValues[value] = true;\n        warning(false, \"Style property values shouldn't contain a semicolon. \" + 'Try \"%s: %s\" instead.%s', name, value.replace(badStyleValueWithSemicolonPattern, ''), getStack());\n      };\n\n      var warnStyleValueIsNaN = function (name, value, getStack) {\n        if (warnedForNaNValue) {\n          return;\n        }\n\n        warnedForNaNValue = true;\n        warning(false, '`NaN` is an invalid value for the `%s` css style property.%s', name, getStack());\n      };\n\n      var warnStyleValueIsInfinity = function (name, value, getStack) {\n        if (warnedForInfinityValue) {\n          return;\n        }\n\n        warnedForInfinityValue = true;\n        warning(false, '`Infinity` is an invalid value for the `%s` css style property.%s', name, getStack());\n      };\n\n      warnValidStyle = function (name, value, getStack) {\n        if (name.indexOf('-') > -1) {\n          warnHyphenatedStyleName(name, getStack);\n        } else if (badVendoredStyleNamePattern.test(name)) {\n          warnBadVendoredStyleName(name, getStack);\n        } else if (badStyleValueWithSemicolonPattern.test(value)) {\n          warnStyleValueWithSemicolon(name, value, getStack);\n        }\n\n        if (typeof value === 'number') {\n          if (isNaN(value)) {\n            warnStyleValueIsNaN(name, value, getStack);\n          } else if (!isFinite(value)) {\n            warnStyleValueIsInfinity(name, value, getStack);\n          }\n        }\n      };\n    }\n\n    var warnValidStyle$1 = warnValidStyle;\n\n    /**\n     * Operations for dealing with CSS properties.\n     */\n\n    /**\n     * This creates a string that is expected to be equivalent to the style\n     * attribute generated by server-side rendering. It by-passes warnings and\n     * security checks so it's not safe to use this value for anything other than\n     * comparison. It is only used in DEV for SSR validation.\n     */\n    function createDangerousStringForStyles(styles) {\n      {\n        var serialized = '';\n        var delimiter = '';\n        for (var styleName in styles) {\n          if (!styles.hasOwnProperty(styleName)) {\n            continue;\n          }\n          var styleValue = styles[styleName];\n          if (styleValue != null) {\n            var isCustomProperty = styleName.indexOf('--') === 0;\n            serialized += delimiter + hyphenateStyleName(styleName) + ':';\n            serialized += dangerousStyleValue(styleName, styleValue, isCustomProperty);\n\n            delimiter = ';';\n          }\n        }\n        return serialized || null;\n      }\n    }\n\n    /**\n     * Sets the value for multiple styles on a node.  If a value is specified as\n     * '' (empty string), the corresponding style property will be unset.\n     *\n     * @param {DOMElement} node\n     * @param {object} styles\n     */\n    function setValueForStyles(node, styles, getStack) {\n      var style = node.style;\n      for (var styleName in styles) {\n        if (!styles.hasOwnProperty(styleName)) {\n          continue;\n        }\n        var isCustomProperty = styleName.indexOf('--') === 0;\n        {\n          if (!isCustomProperty) {\n            warnValidStyle$1(styleName, styles[styleName], getStack);\n          }\n        }\n        var styleValue = dangerousStyleValue(styleName, styles[styleName], isCustomProperty);\n        if (styleName === 'float') {\n          styleName = 'cssFloat';\n        }\n        if (isCustomProperty) {\n          style.setProperty(styleName, styleValue);\n        } else {\n          style[styleName] = styleValue;\n        }\n      }\n    }\n\n    // For HTML, certain tags should omit their close tag. We keep a whitelist for\n    // those special-case tags.\n\n    var omittedCloseTags = {\n      area: true,\n      base: true,\n      br: true,\n      col: true,\n      embed: true,\n      hr: true,\n      img: true,\n      input: true,\n      keygen: true,\n      link: true,\n      meta: true,\n      param: true,\n      source: true,\n      track: true,\n      wbr: true\n    };\n\n    // For HTML, certain tags cannot have children. This has the same purpose as\n    // `omittedCloseTags` except that `menuitem` should still have its closing tag.\n\n    var voidElementTags = _assign({\n      menuitem: true\n    }, omittedCloseTags);\n\n    var HTML$1 = '__html';\n\n    function assertValidProps(tag, props, getStack) {\n      if (!props) {\n        return;\n      }\n      // Note the use of `==` which checks for null or undefined.\n      if (voidElementTags[tag]) {\n        !(props.children == null && props.dangerouslySetInnerHTML == null) ? invariant(false, '%s is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.%s', tag, getStack()) : void 0;\n      }\n      if (props.dangerouslySetInnerHTML != null) {\n        !(props.children == null) ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : void 0;\n        !(typeof props.dangerouslySetInnerHTML === 'object' && HTML$1 in props.dangerouslySetInnerHTML) ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://fb.me/react-invariant-dangerously-set-inner-html for more information.') : void 0;\n      }\n      {\n        warning(props.suppressContentEditableWarning || !props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.%s', getStack());\n      }\n      !(props.style == null || typeof props.style === 'object') ? invariant(false, 'The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + \\'em\\'}} when using JSX.%s', getStack()) : void 0;\n    }\n\n    function isCustomComponent(tagName, props) {\n      if (tagName.indexOf('-') === -1) {\n        return typeof props.is === 'string';\n      }\n      switch (tagName) {\n        // These are reserved SVG and MathML elements.\n        // We don't mind this whitelist too much because we expect it to never grow.\n        // The alternative is to track the namespace in a few places which is convoluted.\n        // https://w3c.github.io/webcomponents/spec/custom/#custom-elements-core-concepts\n        case 'annotation-xml':\n        case 'color-profile':\n        case 'font-face':\n        case 'font-face-src':\n        case 'font-face-uri':\n        case 'font-face-format':\n        case 'font-face-name':\n        case 'missing-glyph':\n          return false;\n        default:\n          return true;\n      }\n    }\n\n    var ariaProperties = {\n      'aria-current': 0, // state\n      'aria-details': 0,\n      'aria-disabled': 0, // state\n      'aria-hidden': 0, // state\n      'aria-invalid': 0, // state\n      'aria-keyshortcuts': 0,\n      'aria-label': 0,\n      'aria-roledescription': 0,\n      // Widget Attributes\n      'aria-autocomplete': 0,\n      'aria-checked': 0,\n      'aria-expanded': 0,\n      'aria-haspopup': 0,\n      'aria-level': 0,\n      'aria-modal': 0,\n      'aria-multiline': 0,\n      'aria-multiselectable': 0,\n      'aria-orientation': 0,\n      'aria-placeholder': 0,\n      'aria-pressed': 0,\n      'aria-readonly': 0,\n      'aria-required': 0,\n      'aria-selected': 0,\n      'aria-sort': 0,\n      'aria-valuemax': 0,\n      'aria-valuemin': 0,\n      'aria-valuenow': 0,\n      'aria-valuetext': 0,\n      // Live Region Attributes\n      'aria-atomic': 0,\n      'aria-busy': 0,\n      'aria-live': 0,\n      'aria-relevant': 0,\n      // Drag-and-Drop Attributes\n      'aria-dropeffect': 0,\n      'aria-grabbed': 0,\n      // Relationship Attributes\n      'aria-activedescendant': 0,\n      'aria-colcount': 0,\n      'aria-colindex': 0,\n      'aria-colspan': 0,\n      'aria-controls': 0,\n      'aria-describedby': 0,\n      'aria-errormessage': 0,\n      'aria-flowto': 0,\n      'aria-labelledby': 0,\n      'aria-owns': 0,\n      'aria-posinset': 0,\n      'aria-rowcount': 0,\n      'aria-rowindex': 0,\n      'aria-rowspan': 0,\n      'aria-setsize': 0\n    };\n\n    var warnedProperties = {};\n    var rARIA = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');\n    var rARIACamel = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');\n\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n    function getStackAddendum() {\n      var stack = ReactDebugCurrentFrame.getStackAddendum();\n      return stack != null ? stack : '';\n    }\n\n    function validateProperty(tagName, name) {\n      if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {\n        return true;\n      }\n\n      if (rARIACamel.test(name)) {\n        var ariaName = 'aria-' + name.slice(4).toLowerCase();\n        var correctName = ariaProperties.hasOwnProperty(ariaName) ? ariaName : null;\n\n        // If this is an aria-* attribute, but is not listed in the known DOM\n        // DOM properties, then it is an invalid aria-* attribute.\n        if (correctName == null) {\n          warning(false, 'Invalid ARIA attribute `%s`. ARIA attributes follow the pattern aria-* and must be lowercase.%s', name, getStackAddendum());\n          warnedProperties[name] = true;\n          return true;\n        }\n        // aria-* attributes should be lowercase; suggest the lowercase version.\n        if (name !== correctName) {\n          warning(false, 'Invalid ARIA attribute `%s`. Did you mean `%s`?%s', name, correctName, getStackAddendum());\n          warnedProperties[name] = true;\n          return true;\n        }\n      }\n\n      if (rARIA.test(name)) {\n        var lowerCasedName = name.toLowerCase();\n        var standardName = ariaProperties.hasOwnProperty(lowerCasedName) ? lowerCasedName : null;\n\n        // If this is an aria-* attribute, but is not listed in the known DOM\n        // DOM properties, then it is an invalid aria-* attribute.\n        if (standardName == null) {\n          warnedProperties[name] = true;\n          return false;\n        }\n        // aria-* attributes should be lowercase; suggest the lowercase version.\n        if (name !== standardName) {\n          warning(false, 'Unknown ARIA attribute `%s`. Did you mean `%s`?%s', name, standardName, getStackAddendum());\n          warnedProperties[name] = true;\n          return true;\n        }\n      }\n\n      return true;\n    }\n\n    function warnInvalidARIAProps(type, props) {\n      var invalidProps = [];\n\n      for (var key in props) {\n        var isValid = validateProperty(type, key);\n        if (!isValid) {\n          invalidProps.push(key);\n        }\n      }\n\n      var unknownPropString = invalidProps.map(function (prop) {\n        return '`' + prop + '`';\n      }).join(', ');\n\n      if (invalidProps.length === 1) {\n        warning(false, 'Invalid aria prop %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, type, getStackAddendum());\n      } else if (invalidProps.length > 1) {\n        warning(false, 'Invalid aria props %s on <%s> tag. ' + 'For details, see https://fb.me/invalid-aria-prop%s', unknownPropString, type, getStackAddendum());\n      }\n    }\n\n    function validateProperties(type, props) {\n      if (isCustomComponent(type, props)) {\n        return;\n      }\n      warnInvalidARIAProps(type, props);\n    }\n\n    var didWarnValueNull = false;\n\n    function getStackAddendum$1() {\n      var stack = ReactDebugCurrentFrame.getStackAddendum();\n      return stack != null ? stack : '';\n    }\n\n    function validateProperties$1(type, props) {\n      if (type !== 'input' && type !== 'textarea' && type !== 'select') {\n        return;\n      }\n\n      if (props != null && props.value === null && !didWarnValueNull) {\n        didWarnValueNull = true;\n        if (type === 'select' && props.multiple) {\n          warning(false, '`value` prop on `%s` should not be null. ' + 'Consider using an empty array when `multiple` is set to `true` ' + 'to clear the component or `undefined` for uncontrolled components.%s', type, getStackAddendum$1());\n        } else {\n          warning(false, '`value` prop on `%s` should not be null. ' + 'Consider using an empty string to clear the component or `undefined` ' + 'for uncontrolled components.%s', type, getStackAddendum$1());\n        }\n      }\n    }\n\n    // When adding attributes to the HTML or SVG whitelist, be sure to\n    // also add them to this module to ensure casing and incorrect name\n    // warnings.\n    var possibleStandardNames = {\n      // HTML\n      accept: 'accept',\n      acceptcharset: 'acceptCharset',\n      'accept-charset': 'acceptCharset',\n      accesskey: 'accessKey',\n      action: 'action',\n      allowfullscreen: 'allowFullScreen',\n      alt: 'alt',\n      as: 'as',\n      async: 'async',\n      autocapitalize: 'autoCapitalize',\n      autocomplete: 'autoComplete',\n      autocorrect: 'autoCorrect',\n      autofocus: 'autoFocus',\n      autoplay: 'autoPlay',\n      autosave: 'autoSave',\n      capture: 'capture',\n      cellpadding: 'cellPadding',\n      cellspacing: 'cellSpacing',\n      challenge: 'challenge',\n      charset: 'charSet',\n      checked: 'checked',\n      children: 'children',\n      cite: 'cite',\n      'class': 'className',\n      classid: 'classID',\n      classname: 'className',\n      cols: 'cols',\n      colspan: 'colSpan',\n      content: 'content',\n      contenteditable: 'contentEditable',\n      contextmenu: 'contextMenu',\n      controls: 'controls',\n      controlslist: 'controlsList',\n      coords: 'coords',\n      crossorigin: 'crossOrigin',\n      dangerouslysetinnerhtml: 'dangerouslySetInnerHTML',\n      data: 'data',\n      datetime: 'dateTime',\n      'default': 'default',\n      defaultchecked: 'defaultChecked',\n      defaultvalue: 'defaultValue',\n      defer: 'defer',\n      dir: 'dir',\n      disabled: 'disabled',\n      download: 'download',\n      draggable: 'draggable',\n      enctype: 'encType',\n      'for': 'htmlFor',\n      form: 'form',\n      formmethod: 'formMethod',\n      formaction: 'formAction',\n      formenctype: 'formEncType',\n      formnovalidate: 'formNoValidate',\n      formtarget: 'formTarget',\n      frameborder: 'frameBorder',\n      headers: 'headers',\n      height: 'height',\n      hidden: 'hidden',\n      high: 'high',\n      href: 'href',\n      hreflang: 'hrefLang',\n      htmlfor: 'htmlFor',\n      httpequiv: 'httpEquiv',\n      'http-equiv': 'httpEquiv',\n      icon: 'icon',\n      id: 'id',\n      innerhtml: 'innerHTML',\n      inputmode: 'inputMode',\n      integrity: 'integrity',\n      is: 'is',\n      itemid: 'itemID',\n      itemprop: 'itemProp',\n      itemref: 'itemRef',\n      itemscope: 'itemScope',\n      itemtype: 'itemType',\n      keyparams: 'keyParams',\n      keytype: 'keyType',\n      kind: 'kind',\n      label: 'label',\n      lang: 'lang',\n      list: 'list',\n      loop: 'loop',\n      low: 'low',\n      manifest: 'manifest',\n      marginwidth: 'marginWidth',\n      marginheight: 'marginHeight',\n      max: 'max',\n      maxlength: 'maxLength',\n      media: 'media',\n      mediagroup: 'mediaGroup',\n      method: 'method',\n      min: 'min',\n      minlength: 'minLength',\n      multiple: 'multiple',\n      muted: 'muted',\n      name: 'name',\n      nonce: 'nonce',\n      novalidate: 'noValidate',\n      open: 'open',\n      optimum: 'optimum',\n      pattern: 'pattern',\n      placeholder: 'placeholder',\n      playsinline: 'playsInline',\n      poster: 'poster',\n      preload: 'preload',\n      profile: 'profile',\n      radiogroup: 'radioGroup',\n      readonly: 'readOnly',\n      referrerpolicy: 'referrerPolicy',\n      rel: 'rel',\n      required: 'required',\n      reversed: 'reversed',\n      role: 'role',\n      rows: 'rows',\n      rowspan: 'rowSpan',\n      sandbox: 'sandbox',\n      scope: 'scope',\n      scoped: 'scoped',\n      scrolling: 'scrolling',\n      seamless: 'seamless',\n      selected: 'selected',\n      shape: 'shape',\n      size: 'size',\n      sizes: 'sizes',\n      span: 'span',\n      spellcheck: 'spellCheck',\n      src: 'src',\n      srcdoc: 'srcDoc',\n      srclang: 'srcLang',\n      srcset: 'srcSet',\n      start: 'start',\n      step: 'step',\n      style: 'style',\n      summary: 'summary',\n      tabindex: 'tabIndex',\n      target: 'target',\n      title: 'title',\n      type: 'type',\n      usemap: 'useMap',\n      value: 'value',\n      width: 'width',\n      wmode: 'wmode',\n      wrap: 'wrap',\n\n      // SVG\n      about: 'about',\n      accentheight: 'accentHeight',\n      'accent-height': 'accentHeight',\n      accumulate: 'accumulate',\n      additive: 'additive',\n      alignmentbaseline: 'alignmentBaseline',\n      'alignment-baseline': 'alignmentBaseline',\n      allowreorder: 'allowReorder',\n      alphabetic: 'alphabetic',\n      amplitude: 'amplitude',\n      arabicform: 'arabicForm',\n      'arabic-form': 'arabicForm',\n      ascent: 'ascent',\n      attributename: 'attributeName',\n      attributetype: 'attributeType',\n      autoreverse: 'autoReverse',\n      azimuth: 'azimuth',\n      basefrequency: 'baseFrequency',\n      baselineshift: 'baselineShift',\n      'baseline-shift': 'baselineShift',\n      baseprofile: 'baseProfile',\n      bbox: 'bbox',\n      begin: 'begin',\n      bias: 'bias',\n      by: 'by',\n      calcmode: 'calcMode',\n      capheight: 'capHeight',\n      'cap-height': 'capHeight',\n      clip: 'clip',\n      clippath: 'clipPath',\n      'clip-path': 'clipPath',\n      clippathunits: 'clipPathUnits',\n      cliprule: 'clipRule',\n      'clip-rule': 'clipRule',\n      color: 'color',\n      colorinterpolation: 'colorInterpolation',\n      'color-interpolation': 'colorInterpolation',\n      colorinterpolationfilters: 'colorInterpolationFilters',\n      'color-interpolation-filters': 'colorInterpolationFilters',\n      colorprofile: 'colorProfile',\n      'color-profile': 'colorProfile',\n      colorrendering: 'colorRendering',\n      'color-rendering': 'colorRendering',\n      contentscripttype: 'contentScriptType',\n      contentstyletype: 'contentStyleType',\n      cursor: 'cursor',\n      cx: 'cx',\n      cy: 'cy',\n      d: 'd',\n      datatype: 'datatype',\n      decelerate: 'decelerate',\n      descent: 'descent',\n      diffuseconstant: 'diffuseConstant',\n      direction: 'direction',\n      display: 'display',\n      divisor: 'divisor',\n      dominantbaseline: 'dominantBaseline',\n      'dominant-baseline': 'dominantBaseline',\n      dur: 'dur',\n      dx: 'dx',\n      dy: 'dy',\n      edgemode: 'edgeMode',\n      elevation: 'elevation',\n      enablebackground: 'enableBackground',\n      'enable-background': 'enableBackground',\n      end: 'end',\n      exponent: 'exponent',\n      externalresourcesrequired: 'externalResourcesRequired',\n      fill: 'fill',\n      fillopacity: 'fillOpacity',\n      'fill-opacity': 'fillOpacity',\n      fillrule: 'fillRule',\n      'fill-rule': 'fillRule',\n      filter: 'filter',\n      filterres: 'filterRes',\n      filterunits: 'filterUnits',\n      floodopacity: 'floodOpacity',\n      'flood-opacity': 'floodOpacity',\n      floodcolor: 'floodColor',\n      'flood-color': 'floodColor',\n      focusable: 'focusable',\n      fontfamily: 'fontFamily',\n      'font-family': 'fontFamily',\n      fontsize: 'fontSize',\n      'font-size': 'fontSize',\n      fontsizeadjust: 'fontSizeAdjust',\n      'font-size-adjust': 'fontSizeAdjust',\n      fontstretch: 'fontStretch',\n      'font-stretch': 'fontStretch',\n      fontstyle: 'fontStyle',\n      'font-style': 'fontStyle',\n      fontvariant: 'fontVariant',\n      'font-variant': 'fontVariant',\n      fontweight: 'fontWeight',\n      'font-weight': 'fontWeight',\n      format: 'format',\n      from: 'from',\n      fx: 'fx',\n      fy: 'fy',\n      g1: 'g1',\n      g2: 'g2',\n      glyphname: 'glyphName',\n      'glyph-name': 'glyphName',\n      glyphorientationhorizontal: 'glyphOrientationHorizontal',\n      'glyph-orientation-horizontal': 'glyphOrientationHorizontal',\n      glyphorientationvertical: 'glyphOrientationVertical',\n      'glyph-orientation-vertical': 'glyphOrientationVertical',\n      glyphref: 'glyphRef',\n      gradienttransform: 'gradientTransform',\n      gradientunits: 'gradientUnits',\n      hanging: 'hanging',\n      horizadvx: 'horizAdvX',\n      'horiz-adv-x': 'horizAdvX',\n      horizoriginx: 'horizOriginX',\n      'horiz-origin-x': 'horizOriginX',\n      ideographic: 'ideographic',\n      imagerendering: 'imageRendering',\n      'image-rendering': 'imageRendering',\n      in2: 'in2',\n      'in': 'in',\n      inlist: 'inlist',\n      intercept: 'intercept',\n      k1: 'k1',\n      k2: 'k2',\n      k3: 'k3',\n      k4: 'k4',\n      k: 'k',\n      kernelmatrix: 'kernelMatrix',\n      kernelunitlength: 'kernelUnitLength',\n      kerning: 'kerning',\n      keypoints: 'keyPoints',\n      keysplines: 'keySplines',\n      keytimes: 'keyTimes',\n      lengthadjust: 'lengthAdjust',\n      letterspacing: 'letterSpacing',\n      'letter-spacing': 'letterSpacing',\n      lightingcolor: 'lightingColor',\n      'lighting-color': 'lightingColor',\n      limitingconeangle: 'limitingConeAngle',\n      local: 'local',\n      markerend: 'markerEnd',\n      'marker-end': 'markerEnd',\n      markerheight: 'markerHeight',\n      markermid: 'markerMid',\n      'marker-mid': 'markerMid',\n      markerstart: 'markerStart',\n      'marker-start': 'markerStart',\n      markerunits: 'markerUnits',\n      markerwidth: 'markerWidth',\n      mask: 'mask',\n      maskcontentunits: 'maskContentUnits',\n      maskunits: 'maskUnits',\n      mathematical: 'mathematical',\n      mode: 'mode',\n      numoctaves: 'numOctaves',\n      offset: 'offset',\n      opacity: 'opacity',\n      operator: 'operator',\n      order: 'order',\n      orient: 'orient',\n      orientation: 'orientation',\n      origin: 'origin',\n      overflow: 'overflow',\n      overlineposition: 'overlinePosition',\n      'overline-position': 'overlinePosition',\n      overlinethickness: 'overlineThickness',\n      'overline-thickness': 'overlineThickness',\n      paintorder: 'paintOrder',\n      'paint-order': 'paintOrder',\n      panose1: 'panose1',\n      'panose-1': 'panose1',\n      pathlength: 'pathLength',\n      patterncontentunits: 'patternContentUnits',\n      patterntransform: 'patternTransform',\n      patternunits: 'patternUnits',\n      pointerevents: 'pointerEvents',\n      'pointer-events': 'pointerEvents',\n      points: 'points',\n      pointsatx: 'pointsAtX',\n      pointsaty: 'pointsAtY',\n      pointsatz: 'pointsAtZ',\n      prefix: 'prefix',\n      preservealpha: 'preserveAlpha',\n      preserveaspectratio: 'preserveAspectRatio',\n      primitiveunits: 'primitiveUnits',\n      property: 'property',\n      r: 'r',\n      radius: 'radius',\n      refx: 'refX',\n      refy: 'refY',\n      renderingintent: 'renderingIntent',\n      'rendering-intent': 'renderingIntent',\n      repeatcount: 'repeatCount',\n      repeatdur: 'repeatDur',\n      requiredextensions: 'requiredExtensions',\n      requiredfeatures: 'requiredFeatures',\n      resource: 'resource',\n      restart: 'restart',\n      result: 'result',\n      results: 'results',\n      rotate: 'rotate',\n      rx: 'rx',\n      ry: 'ry',\n      scale: 'scale',\n      security: 'security',\n      seed: 'seed',\n      shaperendering: 'shapeRendering',\n      'shape-rendering': 'shapeRendering',\n      slope: 'slope',\n      spacing: 'spacing',\n      specularconstant: 'specularConstant',\n      specularexponent: 'specularExponent',\n      speed: 'speed',\n      spreadmethod: 'spreadMethod',\n      startoffset: 'startOffset',\n      stddeviation: 'stdDeviation',\n      stemh: 'stemh',\n      stemv: 'stemv',\n      stitchtiles: 'stitchTiles',\n      stopcolor: 'stopColor',\n      'stop-color': 'stopColor',\n      stopopacity: 'stopOpacity',\n      'stop-opacity': 'stopOpacity',\n      strikethroughposition: 'strikethroughPosition',\n      'strikethrough-position': 'strikethroughPosition',\n      strikethroughthickness: 'strikethroughThickness',\n      'strikethrough-thickness': 'strikethroughThickness',\n      string: 'string',\n      stroke: 'stroke',\n      strokedasharray: 'strokeDasharray',\n      'stroke-dasharray': 'strokeDasharray',\n      strokedashoffset: 'strokeDashoffset',\n      'stroke-dashoffset': 'strokeDashoffset',\n      strokelinecap: 'strokeLinecap',\n      'stroke-linecap': 'strokeLinecap',\n      strokelinejoin: 'strokeLinejoin',\n      'stroke-linejoin': 'strokeLinejoin',\n      strokemiterlimit: 'strokeMiterlimit',\n      'stroke-miterlimit': 'strokeMiterlimit',\n      strokewidth: 'strokeWidth',\n      'stroke-width': 'strokeWidth',\n      strokeopacity: 'strokeOpacity',\n      'stroke-opacity': 'strokeOpacity',\n      suppresscontenteditablewarning: 'suppressContentEditableWarning',\n      suppresshydrationwarning: 'suppressHydrationWarning',\n      surfacescale: 'surfaceScale',\n      systemlanguage: 'systemLanguage',\n      tablevalues: 'tableValues',\n      targetx: 'targetX',\n      targety: 'targetY',\n      textanchor: 'textAnchor',\n      'text-anchor': 'textAnchor',\n      textdecoration: 'textDecoration',\n      'text-decoration': 'textDecoration',\n      textlength: 'textLength',\n      textrendering: 'textRendering',\n      'text-rendering': 'textRendering',\n      to: 'to',\n      transform: 'transform',\n      'typeof': 'typeof',\n      u1: 'u1',\n      u2: 'u2',\n      underlineposition: 'underlinePosition',\n      'underline-position': 'underlinePosition',\n      underlinethickness: 'underlineThickness',\n      'underline-thickness': 'underlineThickness',\n      unicode: 'unicode',\n      unicodebidi: 'unicodeBidi',\n      'unicode-bidi': 'unicodeBidi',\n      unicoderange: 'unicodeRange',\n      'unicode-range': 'unicodeRange',\n      unitsperem: 'unitsPerEm',\n      'units-per-em': 'unitsPerEm',\n      unselectable: 'unselectable',\n      valphabetic: 'vAlphabetic',\n      'v-alphabetic': 'vAlphabetic',\n      values: 'values',\n      vectoreffect: 'vectorEffect',\n      'vector-effect': 'vectorEffect',\n      version: 'version',\n      vertadvy: 'vertAdvY',\n      'vert-adv-y': 'vertAdvY',\n      vertoriginx: 'vertOriginX',\n      'vert-origin-x': 'vertOriginX',\n      vertoriginy: 'vertOriginY',\n      'vert-origin-y': 'vertOriginY',\n      vhanging: 'vHanging',\n      'v-hanging': 'vHanging',\n      videographic: 'vIdeographic',\n      'v-ideographic': 'vIdeographic',\n      viewbox: 'viewBox',\n      viewtarget: 'viewTarget',\n      visibility: 'visibility',\n      vmathematical: 'vMathematical',\n      'v-mathematical': 'vMathematical',\n      vocab: 'vocab',\n      widths: 'widths',\n      wordspacing: 'wordSpacing',\n      'word-spacing': 'wordSpacing',\n      writingmode: 'writingMode',\n      'writing-mode': 'writingMode',\n      x1: 'x1',\n      x2: 'x2',\n      x: 'x',\n      xchannelselector: 'xChannelSelector',\n      xheight: 'xHeight',\n      'x-height': 'xHeight',\n      xlinkactuate: 'xlinkActuate',\n      'xlink:actuate': 'xlinkActuate',\n      xlinkarcrole: 'xlinkArcrole',\n      'xlink:arcrole': 'xlinkArcrole',\n      xlinkhref: 'xlinkHref',\n      'xlink:href': 'xlinkHref',\n      xlinkrole: 'xlinkRole',\n      'xlink:role': 'xlinkRole',\n      xlinkshow: 'xlinkShow',\n      'xlink:show': 'xlinkShow',\n      xlinktitle: 'xlinkTitle',\n      'xlink:title': 'xlinkTitle',\n      xlinktype: 'xlinkType',\n      'xlink:type': 'xlinkType',\n      xmlbase: 'xmlBase',\n      'xml:base': 'xmlBase',\n      xmllang: 'xmlLang',\n      'xml:lang': 'xmlLang',\n      xmlns: 'xmlns',\n      'xml:space': 'xmlSpace',\n      xmlnsxlink: 'xmlnsXlink',\n      'xmlns:xlink': 'xmlnsXlink',\n      xmlspace: 'xmlSpace',\n      y1: 'y1',\n      y2: 'y2',\n      y: 'y',\n      ychannelselector: 'yChannelSelector',\n      z: 'z',\n      zoomandpan: 'zoomAndPan'\n    };\n\n    function getStackAddendum$2() {\n      var stack = ReactDebugCurrentFrame.getStackAddendum();\n      return stack != null ? stack : '';\n    }\n\n    {\n      var warnedProperties$1 = {};\n      var hasOwnProperty$1 = Object.prototype.hasOwnProperty;\n      var EVENT_NAME_REGEX = /^on./;\n      var INVALID_EVENT_NAME_REGEX = /^on[^A-Z]/;\n      var rARIA$1 = new RegExp('^(aria)-[' + ATTRIBUTE_NAME_CHAR + ']*$');\n      var rARIACamel$1 = new RegExp('^(aria)[A-Z][' + ATTRIBUTE_NAME_CHAR + ']*$');\n\n      var validateProperty$1 = function (tagName, name, value, canUseEventSystem) {\n        if (hasOwnProperty$1.call(warnedProperties$1, name) && warnedProperties$1[name]) {\n          return true;\n        }\n\n        var lowerCasedName = name.toLowerCase();\n        if (lowerCasedName === 'onfocusin' || lowerCasedName === 'onfocusout') {\n          warning(false, 'React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.');\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        // We can't rely on the event system being injected on the server.\n        if (canUseEventSystem) {\n          if (registrationNameModules.hasOwnProperty(name)) {\n            return true;\n          }\n          var registrationName = possibleRegistrationNames.hasOwnProperty(lowerCasedName) ? possibleRegistrationNames[lowerCasedName] : null;\n          if (registrationName != null) {\n            warning(false, 'Invalid event handler property `%s`. Did you mean `%s`?%s', name, registrationName, getStackAddendum$2());\n            warnedProperties$1[name] = true;\n            return true;\n          }\n          if (EVENT_NAME_REGEX.test(name)) {\n            warning(false, 'Unknown event handler property `%s`. It will be ignored.%s', name, getStackAddendum$2());\n            warnedProperties$1[name] = true;\n            return true;\n          }\n        } else if (EVENT_NAME_REGEX.test(name)) {\n          // If no event plugins have been injected, we are in a server environment.\n          // So we can't tell if the event name is correct for sure, but we can filter\n          // out known bad ones like `onclick`. We can't suggest a specific replacement though.\n          if (INVALID_EVENT_NAME_REGEX.test(name)) {\n            warning(false, 'Invalid event handler property `%s`. ' + 'React events use the camelCase naming convention, for example `onClick`.%s', name, getStackAddendum$2());\n          }\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        // Let the ARIA attribute hook validate ARIA attributes\n        if (rARIA$1.test(name) || rARIACamel$1.test(name)) {\n          return true;\n        }\n\n        if (lowerCasedName === 'innerhtml') {\n          warning(false, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.');\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        if (lowerCasedName === 'aria') {\n          warning(false, 'The `aria` attribute is reserved for future use in React. ' + 'Pass individual `aria-` attributes instead.');\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        if (lowerCasedName === 'is' && value !== null && value !== undefined && typeof value !== 'string') {\n          warning(false, 'Received a `%s` for a string attribute `is`. If this is expected, cast ' + 'the value to a string.%s', typeof value, getStackAddendum$2());\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        if (typeof value === 'number' && isNaN(value)) {\n          warning(false, 'Received NaN for the `%s` attribute. If this is expected, cast ' + 'the value to a string.%s', name, getStackAddendum$2());\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        var isReserved = isReservedProp(name);\n\n        // Known attributes should match the casing specified in the property config.\n        if (possibleStandardNames.hasOwnProperty(lowerCasedName)) {\n          var standardName = possibleStandardNames[lowerCasedName];\n          if (standardName !== name) {\n            warning(false, 'Invalid DOM property `%s`. Did you mean `%s`?%s', name, standardName, getStackAddendum$2());\n            warnedProperties$1[name] = true;\n            return true;\n          }\n        } else if (!isReserved && name !== lowerCasedName) {\n          // Unknown attributes should have lowercase casing since that's how they\n          // will be cased anyway with server rendering.\n          warning(false, 'React does not recognize the `%s` prop on a DOM element. If you ' + 'intentionally want it to appear in the DOM as a custom ' + 'attribute, spell it as lowercase `%s` instead. ' + 'If you accidentally passed it from a parent component, remove ' + 'it from the DOM element.%s', name, lowerCasedName, getStackAddendum$2());\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        if (typeof value === 'boolean' && !shouldAttributeAcceptBooleanValue(name)) {\n          if (value) {\n            warning(false, 'Received `%s` for a non-boolean attribute `%s`.\\n\\n' + 'If you want to write it to the DOM, pass a string instead: ' + '%s=\"%s\" or %s={value.toString()}.%s', value, name, name, value, name, getStackAddendum$2());\n          } else {\n            warning(false, 'Received `%s` for a non-boolean attribute `%s`.\\n\\n' + 'If you want to write it to the DOM, pass a string instead: ' + '%s=\"%s\" or %s={value.toString()}.\\n\\n' + 'If you used to conditionally omit it with %s={condition && value}, ' + 'pass %s={condition ? value : undefined} instead.%s', value, name, name, value, name, name, name, getStackAddendum$2());\n          }\n          warnedProperties$1[name] = true;\n          return true;\n        }\n\n        // Now that we've validated casing, do not validate\n        // data types for reserved props\n        if (isReserved) {\n          return true;\n        }\n\n        // Warn when a known attribute is a bad type\n        if (!shouldSetAttribute(name, value)) {\n          warnedProperties$1[name] = true;\n          return false;\n        }\n\n        return true;\n      };\n    }\n\n    var warnUnknownProperties = function (type, props, canUseEventSystem) {\n      var unknownProps = [];\n      for (var key in props) {\n        var isValid = validateProperty$1(type, key, props[key], canUseEventSystem);\n        if (!isValid) {\n          unknownProps.push(key);\n        }\n      }\n\n      var unknownPropString = unknownProps.map(function (prop) {\n        return '`' + prop + '`';\n      }).join(', ');\n      if (unknownProps.length === 1) {\n        warning(false, 'Invalid value for prop %s on <%s> tag. Either remove it from the element, ' + 'or pass a string or number value to keep it in the DOM. ' + 'For details, see https://fb.me/react-attribute-behavior%s', unknownPropString, type, getStackAddendum$2());\n      } else if (unknownProps.length > 1) {\n        warning(false, 'Invalid values for props %s on <%s> tag. Either remove them from the element, ' + 'or pass a string or number value to keep them in the DOM. ' + 'For details, see https://fb.me/react-attribute-behavior%s', unknownPropString, type, getStackAddendum$2());\n      }\n    };\n\n    function validateProperties$2(type, props, canUseEventSystem) {\n      if (isCustomComponent(type, props)) {\n        return;\n      }\n      warnUnknownProperties(type, props, canUseEventSystem);\n    }\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var getCurrentFiberOwnerName$1 = ReactDebugCurrentFiber.getCurrentFiberOwnerName;\n    var getCurrentFiberStackAddendum$2 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    var didWarnInvalidHydration = false;\n    var didWarnShadyDOM = false;\n\n    var DANGEROUSLY_SET_INNER_HTML = 'dangerouslySetInnerHTML';\n    var SUPPRESS_CONTENT_EDITABLE_WARNING = 'suppressContentEditableWarning';\n    var SUPPRESS_HYDRATION_WARNING$1 = 'suppressHydrationWarning';\n    var AUTOFOCUS = 'autoFocus';\n    var CHILDREN = 'children';\n    var STYLE = 'style';\n    var HTML = '__html';\n\n    var HTML_NAMESPACE = Namespaces.html;\n\n    var getStack = emptyFunction.thatReturns('');\n\n    {\n      getStack = getCurrentFiberStackAddendum$2;\n\n      var warnedUnknownTags = {\n        // Chrome is the only major browser not shipping <time>. But as of July\n        // 2017 it intends to ship it due to widespread usage. We intentionally\n        // *don't* warn for <time> even if it's unrecognized by Chrome because\n        // it soon will be, and many apps have been using it anyway.\n        time: true,\n        // There are working polyfills for <dialog>. Let people use it.\n        dialog: true\n      };\n\n      var validatePropertiesInDevelopment = function (type, props) {\n        validateProperties(type, props);\n        validateProperties$1(type, props);\n        validateProperties$2(type, props, /* canUseEventSystem */true);\n      };\n\n      // HTML parsing normalizes CR and CRLF to LF.\n      // It also can turn \\u0000 into \\uFFFD inside attributes.\n      // https://www.w3.org/TR/html5/single-page.html#preprocessing-the-input-stream\n      // If we have a mismatch, it might be caused by that.\n      // We will still patch up in this case but not fire the warning.\n      var NORMALIZE_NEWLINES_REGEX = /\\r\\n?/g;\n      var NORMALIZE_NULL_AND_REPLACEMENT_REGEX = /\\u0000|\\uFFFD/g;\n\n      var normalizeMarkupForTextOrAttribute = function (markup) {\n        var markupString = typeof markup === 'string' ? markup : '' + markup;\n        return markupString.replace(NORMALIZE_NEWLINES_REGEX, '\\n').replace(NORMALIZE_NULL_AND_REPLACEMENT_REGEX, '');\n      };\n\n      var warnForTextDifference = function (serverText, clientText) {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        var normalizedClientText = normalizeMarkupForTextOrAttribute(clientText);\n        var normalizedServerText = normalizeMarkupForTextOrAttribute(serverText);\n        if (normalizedServerText === normalizedClientText) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Text content did not match. Server: \"%s\" Client: \"%s\"', normalizedServerText, normalizedClientText);\n      };\n\n      var warnForPropDifference = function (propName, serverValue, clientValue) {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        var normalizedClientValue = normalizeMarkupForTextOrAttribute(clientValue);\n        var normalizedServerValue = normalizeMarkupForTextOrAttribute(serverValue);\n        if (normalizedServerValue === normalizedClientValue) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Prop `%s` did not match. Server: %s Client: %s', propName, JSON.stringify(normalizedServerValue), JSON.stringify(normalizedClientValue));\n      };\n\n      var warnForExtraAttributes = function (attributeNames) {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        var names = [];\n        attributeNames.forEach(function (name) {\n          names.push(name);\n        });\n        warning(false, 'Extra attributes from the server: %s', names);\n      };\n\n      var warnForInvalidEventListener = function (registrationName, listener) {\n        if (listener === false) {\n          warning(false, 'Expected `%s` listener to be a function, instead got `false`.\\n\\n' + 'If you used to conditionally omit it with %s={condition && value}, ' + 'pass %s={condition ? value : undefined} instead.%s', registrationName, registrationName, registrationName, getCurrentFiberStackAddendum$2());\n        } else {\n          warning(false, 'Expected `%s` listener to be a function, instead got a value of `%s` type.%s', registrationName, typeof listener, getCurrentFiberStackAddendum$2());\n        }\n      };\n\n      // Parse the HTML and read it back to normalize the HTML string so that it\n      // can be used for comparison.\n      var normalizeHTML = function (parent, html) {\n        // We could have created a separate document here to avoid\n        // re-initializing custom elements if they exist. But this breaks\n        // how <noscript> is being handled. So we use the same document.\n        // See the discussion in https://github.com/facebook/react/pull/11157.\n        var testElement = parent.namespaceURI === HTML_NAMESPACE ? parent.ownerDocument.createElement(parent.tagName) : parent.ownerDocument.createElementNS(parent.namespaceURI, parent.tagName);\n        testElement.innerHTML = html;\n        return testElement.innerHTML;\n      };\n    }\n\n    function ensureListeningTo(rootContainerElement, registrationName) {\n      var isDocumentOrFragment = rootContainerElement.nodeType === DOCUMENT_NODE || rootContainerElement.nodeType === DOCUMENT_FRAGMENT_NODE;\n      var doc = isDocumentOrFragment ? rootContainerElement : rootContainerElement.ownerDocument;\n      listenTo(registrationName, doc);\n    }\n\n    function getOwnerDocumentFromRootContainer(rootContainerElement) {\n      return rootContainerElement.nodeType === DOCUMENT_NODE ? rootContainerElement : rootContainerElement.ownerDocument;\n    }\n\n    // There are so many media events, it makes sense to just\n    // maintain a list rather than create a `trapBubbledEvent` for each\n    var mediaEvents = {\n      topAbort: 'abort',\n      topCanPlay: 'canplay',\n      topCanPlayThrough: 'canplaythrough',\n      topDurationChange: 'durationchange',\n      topEmptied: 'emptied',\n      topEncrypted: 'encrypted',\n      topEnded: 'ended',\n      topError: 'error',\n      topLoadedData: 'loadeddata',\n      topLoadedMetadata: 'loadedmetadata',\n      topLoadStart: 'loadstart',\n      topPause: 'pause',\n      topPlay: 'play',\n      topPlaying: 'playing',\n      topProgress: 'progress',\n      topRateChange: 'ratechange',\n      topSeeked: 'seeked',\n      topSeeking: 'seeking',\n      topStalled: 'stalled',\n      topSuspend: 'suspend',\n      topTimeUpdate: 'timeupdate',\n      topVolumeChange: 'volumechange',\n      topWaiting: 'waiting'\n    };\n\n    function trapClickOnNonInteractiveElement(node) {\n      // Mobile Safari does not fire properly bubble click events on\n      // non-interactive elements, which means delegated click listeners do not\n      // fire. The workaround for this bug involves attaching an empty click\n      // listener on the target node.\n      // http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html\n      // Just set it using the onclick property so that we don't have to manage any\n      // bookkeeping for it. Not sure if we need to clear it when the listener is\n      // removed.\n      // TODO: Only do this for the relevant Safaris maybe?\n      node.onclick = emptyFunction;\n    }\n\n    function setInitialDOMProperties(tag, domElement, rootContainerElement, nextProps, isCustomComponentTag) {\n      for (var propKey in nextProps) {\n        if (!nextProps.hasOwnProperty(propKey)) {\n          continue;\n        }\n        var nextProp = nextProps[propKey];\n        if (propKey === STYLE) {\n          {\n            if (nextProp) {\n              // Freeze the next style object so that we can assume it won't be\n              // mutated. We have already warned for this in the past.\n              Object.freeze(nextProp);\n            }\n          }\n          // Relies on `updateStylesByID` not mutating `styleUpdates`.\n          setValueForStyles(domElement, nextProp, getStack);\n        } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n          var nextHtml = nextProp ? nextProp[HTML] : undefined;\n          if (nextHtml != null) {\n            setInnerHTML(domElement, nextHtml);\n          }\n        } else if (propKey === CHILDREN) {\n          if (typeof nextProp === 'string') {\n            // Avoid setting initial textContent when the text is empty. In IE11 setting\n            // textContent on a <textarea> will cause the placeholder to not\n            // show within the <textarea> until it has been focused and blurred again.\n            // https://github.com/facebook/react/issues/6731#issuecomment-254874553\n            var canSetTextContent = tag !== 'textarea' || nextProp !== '';\n            if (canSetTextContent) {\n              setTextContent(domElement, nextProp);\n            }\n          } else if (typeof nextProp === 'number') {\n            setTextContent(domElement, '' + nextProp);\n          }\n        } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING$1) {\n          // Noop\n        } else if (propKey === AUTOFOCUS) {\n          // We polyfill it separately on the client during commit.\n          // We blacklist it here rather than in the property list because we emit it in SSR.\n        } else if (registrationNameModules.hasOwnProperty(propKey)) {\n          if (nextProp != null) {\n            if (true && typeof nextProp !== 'function') {\n              warnForInvalidEventListener(propKey, nextProp);\n            }\n            ensureListeningTo(rootContainerElement, propKey);\n          }\n        } else if (isCustomComponentTag) {\n          setValueForAttribute(domElement, propKey, nextProp);\n        } else if (nextProp != null) {\n          // If we're updating to null or undefined, we should remove the property\n          // from the DOM node instead of inadvertently setting to a string. This\n          // brings us in line with the same behavior we have on initial render.\n          setValueForProperty(domElement, propKey, nextProp);\n        }\n      }\n    }\n\n    function updateDOMProperties(domElement, updatePayload, wasCustomComponentTag, isCustomComponentTag) {\n      // TODO: Handle wasCustomComponentTag\n      for (var i = 0; i < updatePayload.length; i += 2) {\n        var propKey = updatePayload[i];\n        var propValue = updatePayload[i + 1];\n        if (propKey === STYLE) {\n          setValueForStyles(domElement, propValue, getStack);\n        } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n          setInnerHTML(domElement, propValue);\n        } else if (propKey === CHILDREN) {\n          setTextContent(domElement, propValue);\n        } else if (isCustomComponentTag) {\n          if (propValue != null) {\n            setValueForAttribute(domElement, propKey, propValue);\n          } else {\n            deleteValueForAttribute(domElement, propKey);\n          }\n        } else if (propValue != null) {\n          setValueForProperty(domElement, propKey, propValue);\n        } else {\n          // If we're updating to null or undefined, we should remove the property\n          // from the DOM node instead of inadvertently setting to a string. This\n          // brings us in line with the same behavior we have on initial render.\n          deleteValueForProperty(domElement, propKey);\n        }\n      }\n    }\n\n    function createElement$1(type, props, rootContainerElement, parentNamespace) {\n      // We create tags in the namespace of their parent container, except HTML\n      var ownerDocument = getOwnerDocumentFromRootContainer(rootContainerElement);\n      var domElement;\n      var namespaceURI = parentNamespace;\n      if (namespaceURI === HTML_NAMESPACE) {\n        namespaceURI = getIntrinsicNamespace(type);\n      }\n      if (namespaceURI === HTML_NAMESPACE) {\n        {\n          var isCustomComponentTag = isCustomComponent(type, props);\n          // Should this check be gated by parent namespace? Not sure we want to\n          // allow <SVG> or <mATH>.\n          warning(isCustomComponentTag || type === type.toLowerCase(), '<%s /> is using uppercase HTML. Always use lowercase HTML tags ' + 'in React.', type);\n        }\n\n        if (type === 'script') {\n          // Create the script via .innerHTML so its \"parser-inserted\" flag is\n          // set to true and it does not execute\n          var div = ownerDocument.createElement('div');\n          div.innerHTML = '<script><' + '/script>'; // eslint-disable-line\n          // This is guaranteed to yield a script element.\n          var firstChild = div.firstChild;\n          domElement = div.removeChild(firstChild);\n        } else if (typeof props.is === 'string') {\n          // $FlowIssue `createElement` should be updated for Web Components\n          domElement = ownerDocument.createElement(type, { is: props.is });\n        } else {\n          // Separate else branch instead of using `props.is || undefined` above because of a Firefox bug.\n          // See discussion in https://github.com/facebook/react/pull/6896\n          // and discussion in https://bugzilla.mozilla.org/show_bug.cgi?id=1276240\n          domElement = ownerDocument.createElement(type);\n        }\n      } else {\n        domElement = ownerDocument.createElementNS(namespaceURI, type);\n      }\n\n      {\n        if (namespaceURI === HTML_NAMESPACE) {\n          if (!isCustomComponentTag && Object.prototype.toString.call(domElement) === '[object HTMLUnknownElement]' && !Object.prototype.hasOwnProperty.call(warnedUnknownTags, type)) {\n            warnedUnknownTags[type] = true;\n            warning(false, 'The tag <%s> is unrecognized in this browser. ' + 'If you meant to render a React component, start its name with ' + 'an uppercase letter.', type);\n          }\n        }\n      }\n\n      return domElement;\n    }\n\n    function createTextNode$1(text, rootContainerElement) {\n      return getOwnerDocumentFromRootContainer(rootContainerElement).createTextNode(text);\n    }\n\n    function setInitialProperties$1(domElement, tag, rawProps, rootContainerElement) {\n      var isCustomComponentTag = isCustomComponent(tag, rawProps);\n      {\n        validatePropertiesInDevelopment(tag, rawProps);\n        if (isCustomComponentTag && !didWarnShadyDOM && domElement.shadyRoot) {\n          warning(false, '%s is using shady DOM. Using shady DOM with React can ' + 'cause things to break subtly.', getCurrentFiberOwnerName$1() || 'A component');\n          didWarnShadyDOM = true;\n        }\n      }\n\n      // TODO: Make sure that we check isMounted before firing any of these events.\n      var props;\n      switch (tag) {\n        case 'iframe':\n        case 'object':\n          trapBubbledEvent('topLoad', 'load', domElement);\n          props = rawProps;\n          break;\n        case 'video':\n        case 'audio':\n          // Create listener for each media event\n          for (var event in mediaEvents) {\n            if (mediaEvents.hasOwnProperty(event)) {\n              trapBubbledEvent(event, mediaEvents[event], domElement);\n            }\n          }\n          props = rawProps;\n          break;\n        case 'source':\n          trapBubbledEvent('topError', 'error', domElement);\n          props = rawProps;\n          break;\n        case 'img':\n        case 'image':\n          trapBubbledEvent('topError', 'error', domElement);\n          trapBubbledEvent('topLoad', 'load', domElement);\n          props = rawProps;\n          break;\n        case 'form':\n          trapBubbledEvent('topReset', 'reset', domElement);\n          trapBubbledEvent('topSubmit', 'submit', domElement);\n          props = rawProps;\n          break;\n        case 'details':\n          trapBubbledEvent('topToggle', 'toggle', domElement);\n          props = rawProps;\n          break;\n        case 'input':\n          initWrapperState(domElement, rawProps);\n          props = getHostProps(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n        case 'option':\n          validateProps(domElement, rawProps);\n          props = getHostProps$1(domElement, rawProps);\n          break;\n        case 'select':\n          initWrapperState$1(domElement, rawProps);\n          props = getHostProps$2(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n        case 'textarea':\n          initWrapperState$2(domElement, rawProps);\n          props = getHostProps$3(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n        default:\n          props = rawProps;\n      }\n\n      assertValidProps(tag, props, getStack);\n\n      setInitialDOMProperties(tag, domElement, rootContainerElement, props, isCustomComponentTag);\n\n      switch (tag) {\n        case 'input':\n          // TODO: Make sure we check if this is still unmounted or do any clean\n          // up necessary since we never stop tracking anymore.\n          track(domElement);\n          postMountWrapper(domElement, rawProps);\n          break;\n        case 'textarea':\n          // TODO: Make sure we check if this is still unmounted or do any clean\n          // up necessary since we never stop tracking anymore.\n          track(domElement);\n          postMountWrapper$3(domElement, rawProps);\n          break;\n        case 'option':\n          postMountWrapper$1(domElement, rawProps);\n          break;\n        case 'select':\n          postMountWrapper$2(domElement, rawProps);\n          break;\n        default:\n          if (typeof props.onClick === 'function') {\n            // TODO: This cast may not be sound for SVG, MathML or custom elements.\n            trapClickOnNonInteractiveElement(domElement);\n          }\n          break;\n      }\n    }\n\n    // Calculate the diff between the two objects.\n    function diffProperties$1(domElement, tag, lastRawProps, nextRawProps, rootContainerElement) {\n      {\n        validatePropertiesInDevelopment(tag, nextRawProps);\n      }\n\n      var updatePayload = null;\n\n      var lastProps;\n      var nextProps;\n      switch (tag) {\n        case 'input':\n          lastProps = getHostProps(domElement, lastRawProps);\n          nextProps = getHostProps(domElement, nextRawProps);\n          updatePayload = [];\n          break;\n        case 'option':\n          lastProps = getHostProps$1(domElement, lastRawProps);\n          nextProps = getHostProps$1(domElement, nextRawProps);\n          updatePayload = [];\n          break;\n        case 'select':\n          lastProps = getHostProps$2(domElement, lastRawProps);\n          nextProps = getHostProps$2(domElement, nextRawProps);\n          updatePayload = [];\n          break;\n        case 'textarea':\n          lastProps = getHostProps$3(domElement, lastRawProps);\n          nextProps = getHostProps$3(domElement, nextRawProps);\n          updatePayload = [];\n          break;\n        default:\n          lastProps = lastRawProps;\n          nextProps = nextRawProps;\n          if (typeof lastProps.onClick !== 'function' && typeof nextProps.onClick === 'function') {\n            // TODO: This cast may not be sound for SVG, MathML or custom elements.\n            trapClickOnNonInteractiveElement(domElement);\n          }\n          break;\n      }\n\n      assertValidProps(tag, nextProps, getStack);\n\n      var propKey;\n      var styleName;\n      var styleUpdates = null;\n      for (propKey in lastProps) {\n        if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey) || lastProps[propKey] == null) {\n          continue;\n        }\n        if (propKey === STYLE) {\n          var lastStyle = lastProps[propKey];\n          for (styleName in lastStyle) {\n            if (lastStyle.hasOwnProperty(styleName)) {\n              if (!styleUpdates) {\n                styleUpdates = {};\n              }\n              styleUpdates[styleName] = '';\n            }\n          }\n        } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN) {\n          // Noop. This is handled by the clear text mechanism.\n        } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING$1) {\n          // Noop\n        } else if (propKey === AUTOFOCUS) {\n          // Noop. It doesn't work on updates anyway.\n        } else if (registrationNameModules.hasOwnProperty(propKey)) {\n          // This is a special case. If any listener updates we need to ensure\n          // that the \"current\" fiber pointer gets updated so we need a commit\n          // to update this element.\n          if (!updatePayload) {\n            updatePayload = [];\n          }\n        } else {\n          // For all other deleted properties we add it to the queue. We use\n          // the whitelist in the commit phase instead.\n          (updatePayload = updatePayload || []).push(propKey, null);\n        }\n      }\n      for (propKey in nextProps) {\n        var nextProp = nextProps[propKey];\n        var lastProp = lastProps != null ? lastProps[propKey] : undefined;\n        if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp || nextProp == null && lastProp == null) {\n          continue;\n        }\n        if (propKey === STYLE) {\n          {\n            if (nextProp) {\n              // Freeze the next style object so that we can assume it won't be\n              // mutated. We have already warned for this in the past.\n              Object.freeze(nextProp);\n            }\n          }\n          if (lastProp) {\n            // Unset styles on `lastProp` but not on `nextProp`.\n            for (styleName in lastProp) {\n              if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) {\n                if (!styleUpdates) {\n                  styleUpdates = {};\n                }\n                styleUpdates[styleName] = '';\n              }\n            }\n            // Update styles that changed since `lastProp`.\n            for (styleName in nextProp) {\n              if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) {\n                if (!styleUpdates) {\n                  styleUpdates = {};\n                }\n                styleUpdates[styleName] = nextProp[styleName];\n              }\n            }\n          } else {\n            // Relies on `updateStylesByID` not mutating `styleUpdates`.\n            if (!styleUpdates) {\n              if (!updatePayload) {\n                updatePayload = [];\n              }\n              updatePayload.push(propKey, styleUpdates);\n            }\n            styleUpdates = nextProp;\n          }\n        } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n          var nextHtml = nextProp ? nextProp[HTML] : undefined;\n          var lastHtml = lastProp ? lastProp[HTML] : undefined;\n          if (nextHtml != null) {\n            if (lastHtml !== nextHtml) {\n              (updatePayload = updatePayload || []).push(propKey, '' + nextHtml);\n            }\n          } else {\n            // TODO: It might be too late to clear this if we have children\n            // inserted already.\n          }\n        } else if (propKey === CHILDREN) {\n          if (lastProp !== nextProp && (typeof nextProp === 'string' || typeof nextProp === 'number')) {\n            (updatePayload = updatePayload || []).push(propKey, '' + nextProp);\n          }\n        } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING$1) {\n          // Noop\n        } else if (registrationNameModules.hasOwnProperty(propKey)) {\n          if (nextProp != null) {\n            // We eagerly listen to this even though we haven't committed yet.\n            if (true && typeof nextProp !== 'function') {\n              warnForInvalidEventListener(propKey, nextProp);\n            }\n            ensureListeningTo(rootContainerElement, propKey);\n          }\n          if (!updatePayload && lastProp !== nextProp) {\n            // This is a special case. If any listener updates we need to ensure\n            // that the \"current\" props pointer gets updated so we need a commit\n            // to update this element.\n            updatePayload = [];\n          }\n        } else {\n          // For any other property we always add it to the queue and then we\n          // filter it out using the whitelist during the commit.\n          (updatePayload = updatePayload || []).push(propKey, nextProp);\n        }\n      }\n      if (styleUpdates) {\n        (updatePayload = updatePayload || []).push(STYLE, styleUpdates);\n      }\n      return updatePayload;\n    }\n\n    // Apply the diff.\n    function updateProperties$1(domElement, updatePayload, tag, lastRawProps, nextRawProps) {\n      // Update checked *before* name.\n      // In the middle of an update, it is possible to have multiple checked.\n      // When a checked radio tries to change name, browser makes another radio's checked false.\n      if (tag === 'input' && nextRawProps.type === 'radio' && nextRawProps.name != null) {\n        updateChecked(domElement, nextRawProps);\n      }\n\n      var wasCustomComponentTag = isCustomComponent(tag, lastRawProps);\n      var isCustomComponentTag = isCustomComponent(tag, nextRawProps);\n      // Apply the diff.\n      updateDOMProperties(domElement, updatePayload, wasCustomComponentTag, isCustomComponentTag);\n\n      // TODO: Ensure that an update gets scheduled if any of the special props\n      // changed.\n      switch (tag) {\n        case 'input':\n          // Update the wrapper around inputs *after* updating props. This has to\n          // happen after `updateDOMProperties`. Otherwise HTML5 input validations\n          // raise warnings and prevent the new value from being assigned.\n          updateWrapper(domElement, nextRawProps);\n          break;\n        case 'textarea':\n          updateWrapper$1(domElement, nextRawProps);\n          break;\n        case 'select':\n          // <select> value update needs to occur after <option> children\n          // reconciliation\n          postUpdateWrapper(domElement, nextRawProps);\n          break;\n      }\n    }\n\n    function diffHydratedProperties$1(domElement, tag, rawProps, parentNamespace, rootContainerElement) {\n      {\n        var suppressHydrationWarning = rawProps[SUPPRESS_HYDRATION_WARNING$1] === true;\n        var isCustomComponentTag = isCustomComponent(tag, rawProps);\n        validatePropertiesInDevelopment(tag, rawProps);\n        if (isCustomComponentTag && !didWarnShadyDOM && domElement.shadyRoot) {\n          warning(false, '%s is using shady DOM. Using shady DOM with React can ' + 'cause things to break subtly.', getCurrentFiberOwnerName$1() || 'A component');\n          didWarnShadyDOM = true;\n        }\n      }\n\n      // TODO: Make sure that we check isMounted before firing any of these events.\n      switch (tag) {\n        case 'iframe':\n        case 'object':\n          trapBubbledEvent('topLoad', 'load', domElement);\n          break;\n        case 'video':\n        case 'audio':\n          // Create listener for each media event\n          for (var event in mediaEvents) {\n            if (mediaEvents.hasOwnProperty(event)) {\n              trapBubbledEvent(event, mediaEvents[event], domElement);\n            }\n          }\n          break;\n        case 'source':\n          trapBubbledEvent('topError', 'error', domElement);\n          break;\n        case 'img':\n        case 'image':\n          trapBubbledEvent('topError', 'error', domElement);\n          trapBubbledEvent('topLoad', 'load', domElement);\n          break;\n        case 'form':\n          trapBubbledEvent('topReset', 'reset', domElement);\n          trapBubbledEvent('topSubmit', 'submit', domElement);\n          break;\n        case 'details':\n          trapBubbledEvent('topToggle', 'toggle', domElement);\n          break;\n        case 'input':\n          initWrapperState(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n        case 'option':\n          validateProps(domElement, rawProps);\n          break;\n        case 'select':\n          initWrapperState$1(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n        case 'textarea':\n          initWrapperState$2(domElement, rawProps);\n          trapBubbledEvent('topInvalid', 'invalid', domElement);\n          // For controlled components we always need to ensure we're listening\n          // to onChange. Even if there is no listener.\n          ensureListeningTo(rootContainerElement, 'onChange');\n          break;\n      }\n\n      assertValidProps(tag, rawProps, getStack);\n\n      {\n        var extraAttributeNames = new Set();\n        var attributes = domElement.attributes;\n        for (var i = 0; i < attributes.length; i++) {\n          var name = attributes[i].name.toLowerCase();\n          switch (name) {\n            // Built-in SSR attribute is whitelisted\n            case 'data-reactroot':\n              break;\n            // Controlled attributes are not validated\n            // TODO: Only ignore them on controlled tags.\n            case 'value':\n              break;\n            case 'checked':\n              break;\n            case 'selected':\n              break;\n            default:\n              // Intentionally use the original name.\n              // See discussion in https://github.com/facebook/react/pull/10676.\n              extraAttributeNames.add(attributes[i].name);\n          }\n        }\n      }\n\n      var updatePayload = null;\n      for (var propKey in rawProps) {\n        if (!rawProps.hasOwnProperty(propKey)) {\n          continue;\n        }\n        var nextProp = rawProps[propKey];\n        if (propKey === CHILDREN) {\n          // For text content children we compare against textContent. This\n          // might match additional HTML that is hidden when we read it using\n          // textContent. E.g. \"foo\" will match \"f<span>oo</span>\" but that still\n          // satisfies our requirement. Our requirement is not to produce perfect\n          // HTML and attributes. Ideally we should preserve structure but it's\n          // ok not to if the visible content is still enough to indicate what\n          // even listeners these nodes might be wired up to.\n          // TODO: Warn if there is more than a single textNode as a child.\n          // TODO: Should we use domElement.firstChild.nodeValue to compare?\n          if (typeof nextProp === 'string') {\n            if (domElement.textContent !== nextProp) {\n              if (true && !suppressHydrationWarning) {\n                warnForTextDifference(domElement.textContent, nextProp);\n              }\n              updatePayload = [CHILDREN, nextProp];\n            }\n          } else if (typeof nextProp === 'number') {\n            if (domElement.textContent !== '' + nextProp) {\n              if (true && !suppressHydrationWarning) {\n                warnForTextDifference(domElement.textContent, nextProp);\n              }\n              updatePayload = [CHILDREN, '' + nextProp];\n            }\n          }\n        } else if (registrationNameModules.hasOwnProperty(propKey)) {\n          if (nextProp != null) {\n            if (true && typeof nextProp !== 'function') {\n              warnForInvalidEventListener(propKey, nextProp);\n            }\n            ensureListeningTo(rootContainerElement, propKey);\n          }\n        } else {\n          // Validate that the properties correspond to their expected values.\n          var serverValue;\n          var propertyInfo;\n          if (suppressHydrationWarning) {\n            // Don't bother comparing. We're ignoring all these warnings.\n          } else if (propKey === SUPPRESS_CONTENT_EDITABLE_WARNING || propKey === SUPPRESS_HYDRATION_WARNING$1 ||\n          // Controlled attributes are not validated\n          // TODO: Only ignore them on controlled tags.\n          propKey === 'value' || propKey === 'checked' || propKey === 'selected') {\n            // Noop\n          } else if (propKey === DANGEROUSLY_SET_INNER_HTML) {\n            var rawHtml = nextProp ? nextProp[HTML] || '' : '';\n            var serverHTML = domElement.innerHTML;\n            var expectedHTML = normalizeHTML(domElement, rawHtml);\n            if (expectedHTML !== serverHTML) {\n              warnForPropDifference(propKey, serverHTML, expectedHTML);\n            }\n          } else if (propKey === STYLE) {\n            // $FlowFixMe - Should be inferred as not undefined.\n            extraAttributeNames['delete'](propKey);\n            var expectedStyle = createDangerousStringForStyles(nextProp);\n            serverValue = domElement.getAttribute('style');\n            if (expectedStyle !== serverValue) {\n              warnForPropDifference(propKey, serverValue, expectedStyle);\n            }\n          } else if (isCustomComponentTag) {\n            // $FlowFixMe - Should be inferred as not undefined.\n            extraAttributeNames['delete'](propKey.toLowerCase());\n            serverValue = getValueForAttribute(domElement, propKey, nextProp);\n\n            if (nextProp !== serverValue) {\n              warnForPropDifference(propKey, serverValue, nextProp);\n            }\n          } else if (shouldSetAttribute(propKey, nextProp)) {\n            if (propertyInfo = getPropertyInfo(propKey)) {\n              // $FlowFixMe - Should be inferred as not undefined.\n              extraAttributeNames['delete'](propertyInfo.attributeName);\n              serverValue = getValueForProperty(domElement, propKey, nextProp);\n            } else {\n              var ownNamespace = parentNamespace;\n              if (ownNamespace === HTML_NAMESPACE) {\n                ownNamespace = getIntrinsicNamespace(tag);\n              }\n              if (ownNamespace === HTML_NAMESPACE) {\n                // $FlowFixMe - Should be inferred as not undefined.\n                extraAttributeNames['delete'](propKey.toLowerCase());\n              } else {\n                // $FlowFixMe - Should be inferred as not undefined.\n                extraAttributeNames['delete'](propKey);\n              }\n              serverValue = getValueForAttribute(domElement, propKey, nextProp);\n            }\n\n            if (nextProp !== serverValue) {\n              warnForPropDifference(propKey, serverValue, nextProp);\n            }\n          }\n        }\n      }\n\n      {\n        // $FlowFixMe - Should be inferred as not undefined.\n        if (extraAttributeNames.size > 0 && !suppressHydrationWarning) {\n          // $FlowFixMe - Should be inferred as not undefined.\n          warnForExtraAttributes(extraAttributeNames);\n        }\n      }\n\n      switch (tag) {\n        case 'input':\n          // TODO: Make sure we check if this is still unmounted or do any clean\n          // up necessary since we never stop tracking anymore.\n          track(domElement);\n          postMountWrapper(domElement, rawProps);\n          break;\n        case 'textarea':\n          // TODO: Make sure we check if this is still unmounted or do any clean\n          // up necessary since we never stop tracking anymore.\n          track(domElement);\n          postMountWrapper$3(domElement, rawProps);\n          break;\n        case 'select':\n        case 'option':\n          // For input and textarea we current always set the value property at\n          // post mount to force it to diverge from attributes. However, for\n          // option and select we don't quite do the same thing and select\n          // is not resilient to the DOM state changing so we don't do that here.\n          // TODO: Consider not doing this for input and textarea.\n          break;\n        default:\n          if (typeof rawProps.onClick === 'function') {\n            // TODO: This cast may not be sound for SVG, MathML or custom elements.\n            trapClickOnNonInteractiveElement(domElement);\n          }\n          break;\n      }\n\n      return updatePayload;\n    }\n\n    function diffHydratedText$1(textNode, text) {\n      var isDifferent = textNode.nodeValue !== text;\n      return isDifferent;\n    }\n\n    function warnForUnmatchedText$1(textNode, text) {\n      {\n        warnForTextDifference(textNode.nodeValue, text);\n      }\n    }\n\n    function warnForDeletedHydratableElement$1(parentNode, child) {\n      {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Did not expect server HTML to contain a <%s> in <%s>.', child.nodeName.toLowerCase(), parentNode.nodeName.toLowerCase());\n      }\n    }\n\n    function warnForDeletedHydratableText$1(parentNode, child) {\n      {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Did not expect server HTML to contain the text node \"%s\" in <%s>.', child.nodeValue, parentNode.nodeName.toLowerCase());\n      }\n    }\n\n    function warnForInsertedHydratedElement$1(parentNode, tag, props) {\n      {\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Expected server HTML to contain a matching <%s> in <%s>.', tag, parentNode.nodeName.toLowerCase());\n      }\n    }\n\n    function warnForInsertedHydratedText$1(parentNode, text) {\n      {\n        if (text === '') {\n          // We expect to insert empty text nodes since they're not represented in\n          // the HTML.\n          // TODO: Remove this special case if we can just avoid inserting empty\n          // text nodes.\n          return;\n        }\n        if (didWarnInvalidHydration) {\n          return;\n        }\n        didWarnInvalidHydration = true;\n        warning(false, 'Expected server HTML to contain a matching text node for \"%s\" in <%s>.', text, parentNode.nodeName.toLowerCase());\n      }\n    }\n\n    function restoreControlledState(domElement, tag, props) {\n      switch (tag) {\n        case 'input':\n          restoreControlledState$1(domElement, props);\n          return;\n        case 'textarea':\n          restoreControlledState$3(domElement, props);\n          return;\n        case 'select':\n          restoreControlledState$2(domElement, props);\n          return;\n      }\n    }\n\n    var ReactDOMFiberComponent = Object.freeze({\n      createElement: createElement$1,\n      createTextNode: createTextNode$1,\n      setInitialProperties: setInitialProperties$1,\n      diffProperties: diffProperties$1,\n      updateProperties: updateProperties$1,\n      diffHydratedProperties: diffHydratedProperties$1,\n      diffHydratedText: diffHydratedText$1,\n      warnForUnmatchedText: warnForUnmatchedText$1,\n      warnForDeletedHydratableElement: warnForDeletedHydratableElement$1,\n      warnForDeletedHydratableText: warnForDeletedHydratableText$1,\n      warnForInsertedHydratedElement: warnForInsertedHydratedElement$1,\n      warnForInsertedHydratedText: warnForInsertedHydratedText$1,\n      restoreControlledState: restoreControlledState\n    });\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var getCurrentFiberStackAddendum$6 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;\n\n    var validateDOMNesting = emptyFunction;\n\n    {\n      // This validation code was written based on the HTML5 parsing spec:\n      // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope\n      //\n      // Note: this does not catch all invalid nesting, nor does it try to (as it's\n      // not clear what practical benefit doing so provides); instead, we warn only\n      // for cases where the parser will give a parse tree differing from what React\n      // intended. For example, <b><div></div></b> is invalid but we don't warn\n      // because it still parses correctly; we do warn for other cases like nested\n      // <p> tags where the beginning of the second element implicitly closes the\n      // first, causing a confusing mess.\n\n      // https://html.spec.whatwg.org/multipage/syntax.html#special\n      var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp'];\n\n      // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope\n      var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template',\n\n      // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point\n      // TODO: Distinguish by namespace here -- for <title>, including it here\n      // errs on the side of fewer warnings\n      'foreignObject', 'desc', 'title'];\n\n      // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope\n      var buttonScopeTags = inScopeTags.concat(['button']);\n\n      // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags\n      var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt'];\n\n      var emptyAncestorInfo = {\n        current: null,\n\n        formTag: null,\n        aTagInScope: null,\n        buttonTagInScope: null,\n        nobrTagInScope: null,\n        pTagInButtonScope: null,\n\n        listItemTagAutoclosing: null,\n        dlItemTagAutoclosing: null\n      };\n\n      var updatedAncestorInfo$1 = function (oldInfo, tag, instance) {\n        var ancestorInfo = _assign({}, oldInfo || emptyAncestorInfo);\n        var info = { tag: tag, instance: instance };\n\n        if (inScopeTags.indexOf(tag) !== -1) {\n          ancestorInfo.aTagInScope = null;\n          ancestorInfo.buttonTagInScope = null;\n          ancestorInfo.nobrTagInScope = null;\n        }\n        if (buttonScopeTags.indexOf(tag) !== -1) {\n          ancestorInfo.pTagInButtonScope = null;\n        }\n\n        // See rules for 'li', 'dd', 'dt' start tags in\n        // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n        if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') {\n          ancestorInfo.listItemTagAutoclosing = null;\n          ancestorInfo.dlItemTagAutoclosing = null;\n        }\n\n        ancestorInfo.current = info;\n\n        if (tag === 'form') {\n          ancestorInfo.formTag = info;\n        }\n        if (tag === 'a') {\n          ancestorInfo.aTagInScope = info;\n        }\n        if (tag === 'button') {\n          ancestorInfo.buttonTagInScope = info;\n        }\n        if (tag === 'nobr') {\n          ancestorInfo.nobrTagInScope = info;\n        }\n        if (tag === 'p') {\n          ancestorInfo.pTagInButtonScope = info;\n        }\n        if (tag === 'li') {\n          ancestorInfo.listItemTagAutoclosing = info;\n        }\n        if (tag === 'dd' || tag === 'dt') {\n          ancestorInfo.dlItemTagAutoclosing = info;\n        }\n\n        return ancestorInfo;\n      };\n\n      /**\n       * Returns whether\n       */\n      var isTagValidWithParent = function (tag, parentTag) {\n        // First, let's check if we're in an unusual parsing mode...\n        switch (parentTag) {\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect\n          case 'select':\n            return tag === 'option' || tag === 'optgroup' || tag === '#text';\n          case 'optgroup':\n            return tag === 'option' || tag === '#text';\n          // Strictly speaking, seeing an <option> doesn't mean we're in a <select>\n          // but\n          case 'option':\n            return tag === '#text';\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption\n          // No special behavior since these rules fall back to \"in body\" mode for\n          // all except special table nodes which cause bad parsing behavior anyway.\n\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr\n          case 'tr':\n            return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template';\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody\n          case 'tbody':\n          case 'thead':\n          case 'tfoot':\n            return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template';\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup\n          case 'colgroup':\n            return tag === 'col' || tag === 'template';\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable\n          case 'table':\n            return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template';\n          // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead\n          case 'head':\n            return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template';\n          // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element\n          case 'html':\n            return tag === 'head' || tag === 'body';\n          case '#document':\n            return tag === 'html';\n        }\n\n        // Probably in the \"in body\" parsing mode, so we outlaw only tag combos\n        // where the parsing rules cause implicit opens or closes to be added.\n        // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody\n        switch (tag) {\n          case 'h1':\n          case 'h2':\n          case 'h3':\n          case 'h4':\n          case 'h5':\n          case 'h6':\n            return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6';\n\n          case 'rp':\n          case 'rt':\n            return impliedEndTags.indexOf(parentTag) === -1;\n\n          case 'body':\n          case 'caption':\n          case 'col':\n          case 'colgroup':\n          case 'frame':\n          case 'head':\n          case 'html':\n          case 'tbody':\n          case 'td':\n          case 'tfoot':\n          case 'th':\n          case 'thead':\n          case 'tr':\n            // These tags are only valid with a few parents that have special child\n            // parsing rules -- if we're down here, then none of those matched and\n            // so we allow it only if we don't know what the parent is, as all other\n            // cases are invalid.\n            return parentTag == null;\n        }\n\n        return true;\n      };\n\n      /**\n       * Returns whether\n       */\n      var findInvalidAncestorForTag = function (tag, ancestorInfo) {\n        switch (tag) {\n          case 'address':\n          case 'article':\n          case 'aside':\n          case 'blockquote':\n          case 'center':\n          case 'details':\n          case 'dialog':\n          case 'dir':\n          case 'div':\n          case 'dl':\n          case 'fieldset':\n          case 'figcaption':\n          case 'figure':\n          case 'footer':\n          case 'header':\n          case 'hgroup':\n          case 'main':\n          case 'menu':\n          case 'nav':\n          case 'ol':\n          case 'p':\n          case 'section':\n          case 'summary':\n          case 'ul':\n          case 'pre':\n          case 'listing':\n          case 'table':\n          case 'hr':\n          case 'xmp':\n          case 'h1':\n          case 'h2':\n          case 'h3':\n          case 'h4':\n          case 'h5':\n          case 'h6':\n            return ancestorInfo.pTagInButtonScope;\n\n          case 'form':\n            return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope;\n\n          case 'li':\n            return ancestorInfo.listItemTagAutoclosing;\n\n          case 'dd':\n          case 'dt':\n            return ancestorInfo.dlItemTagAutoclosing;\n\n          case 'button':\n            return ancestorInfo.buttonTagInScope;\n\n          case 'a':\n            // Spec says something about storing a list of markers, but it sounds\n            // equivalent to this check.\n            return ancestorInfo.aTagInScope;\n\n          case 'nobr':\n            return ancestorInfo.nobrTagInScope;\n        }\n\n        return null;\n      };\n\n      var didWarn = {};\n\n      validateDOMNesting = function (childTag, childText, ancestorInfo) {\n        ancestorInfo = ancestorInfo || emptyAncestorInfo;\n        var parentInfo = ancestorInfo.current;\n        var parentTag = parentInfo && parentInfo.tag;\n\n        if (childText != null) {\n          warning(childTag == null, 'validateDOMNesting: when childText is passed, childTag should be null');\n          childTag = '#text';\n        }\n\n        var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo;\n        var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo);\n        var invalidParentOrAncestor = invalidParent || invalidAncestor;\n        if (!invalidParentOrAncestor) {\n          return;\n        }\n\n        var ancestorTag = invalidParentOrAncestor.tag;\n        var addendum = getCurrentFiberStackAddendum$6();\n\n        var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + addendum;\n        if (didWarn[warnKey]) {\n          return;\n        }\n        didWarn[warnKey] = true;\n\n        var tagDisplayName = childTag;\n        var whitespaceInfo = '';\n        if (childTag === '#text') {\n          if (/\\S/.test(childText)) {\n            tagDisplayName = 'Text nodes';\n          } else {\n            tagDisplayName = 'Whitespace text nodes';\n            whitespaceInfo = \" Make sure you don't have any extra whitespace between tags on \" + 'each line of your source code.';\n          }\n        } else {\n          tagDisplayName = '<' + childTag + '>';\n        }\n\n        if (invalidParent) {\n          var info = '';\n          if (ancestorTag === 'table' && childTag === 'tr') {\n            info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.';\n          }\n          warning(false, 'validateDOMNesting(...): %s cannot appear as a child of <%s>.%s%s%s', tagDisplayName, ancestorTag, whitespaceInfo, info, addendum);\n        } else {\n          warning(false, 'validateDOMNesting(...): %s cannot appear as a descendant of ' + '<%s>.%s', tagDisplayName, ancestorTag, addendum);\n        }\n      };\n\n      // TODO: turn this into a named export\n      validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo$1;\n\n      // For testing\n      validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) {\n        ancestorInfo = ancestorInfo || emptyAncestorInfo;\n        var parentInfo = ancestorInfo.current;\n        var parentTag = parentInfo && parentInfo.tag;\n        return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo);\n      };\n    }\n\n    var validateDOMNesting$1 = validateDOMNesting;\n\n    // TODO: direct imports like some-package/src/* are bad. Fix me.\n    var createElement = createElement$1;\n    var createTextNode = createTextNode$1;\n    var setInitialProperties = setInitialProperties$1;\n    var diffProperties = diffProperties$1;\n    var updateProperties = updateProperties$1;\n    var diffHydratedProperties = diffHydratedProperties$1;\n    var diffHydratedText = diffHydratedText$1;\n    var warnForUnmatchedText = warnForUnmatchedText$1;\n    var warnForDeletedHydratableElement = warnForDeletedHydratableElement$1;\n    var warnForDeletedHydratableText = warnForDeletedHydratableText$1;\n    var warnForInsertedHydratedElement = warnForInsertedHydratedElement$1;\n    var warnForInsertedHydratedText = warnForInsertedHydratedText$1;\n    var updatedAncestorInfo = validateDOMNesting$1.updatedAncestorInfo;\n    var precacheFiberNode = precacheFiberNode$1;\n    var updateFiberProps = updateFiberProps$1;\n\n    {\n      var SUPPRESS_HYDRATION_WARNING = 'suppressHydrationWarning';\n      if (typeof Map !== 'function' || Map.prototype == null || typeof Map.prototype.forEach !== 'function' || typeof Set !== 'function' || Set.prototype == null || typeof Set.prototype.clear !== 'function' || typeof Set.prototype.forEach !== 'function') {\n        warning(false, 'React depends on Map and Set built-in types. Make sure that you load a ' + 'polyfill in older browsers. http://fb.me/react-polyfills');\n      }\n    }\n\n    injection$3.injectFiberControlledHostComponent(ReactDOMFiberComponent);\n\n    var eventsEnabled = null;\n    var selectionInformation = null;\n\n    /**\n     * True if the supplied DOM node is a valid node element.\n     *\n     * @param {?DOMElement} node The candidate DOM node.\n     * @return {boolean} True if the DOM is a valid DOM node.\n     * @internal\n     */\n    function isValidContainer(node) {\n      return !!(node && (node.nodeType === ELEMENT_NODE || node.nodeType === DOCUMENT_NODE || node.nodeType === DOCUMENT_FRAGMENT_NODE || node.nodeType === COMMENT_NODE && node.nodeValue === ' react-mount-point-unstable '));\n    }\n\n    function getReactRootElementInContainer(container) {\n      if (!container) {\n        return null;\n      }\n\n      if (container.nodeType === DOCUMENT_NODE) {\n        return container.documentElement;\n      } else {\n        return container.firstChild;\n      }\n    }\n\n    function shouldHydrateDueToLegacyHeuristic(container) {\n      var rootElement = getReactRootElementInContainer(container);\n      return !!(rootElement && rootElement.nodeType === ELEMENT_NODE && rootElement.hasAttribute(ROOT_ATTRIBUTE_NAME));\n    }\n\n    function shouldAutoFocusHostComponent(type, props) {\n      switch (type) {\n        case 'button':\n        case 'input':\n        case 'select':\n        case 'textarea':\n          return !!props.autoFocus;\n      }\n      return false;\n    }\n\n    var DOMRenderer = reactReconciler({\n      getRootHostContext: function (rootContainerInstance) {\n        var type = void 0;\n        var namespace = void 0;\n        var nodeType = rootContainerInstance.nodeType;\n        switch (nodeType) {\n          case DOCUMENT_NODE:\n          case DOCUMENT_FRAGMENT_NODE:\n            {\n              type = nodeType === DOCUMENT_NODE ? '#document' : '#fragment';\n              var root = rootContainerInstance.documentElement;\n              namespace = root ? root.namespaceURI : getChildNamespace(null, '');\n              break;\n            }\n          default:\n            {\n              var container = nodeType === COMMENT_NODE ? rootContainerInstance.parentNode : rootContainerInstance;\n              var ownNamespace = container.namespaceURI || null;\n              type = container.tagName;\n              namespace = getChildNamespace(ownNamespace, type);\n              break;\n            }\n        }\n        {\n          var validatedTag = type.toLowerCase();\n          var _ancestorInfo = updatedAncestorInfo(null, validatedTag, null);\n          return { namespace: namespace, ancestorInfo: _ancestorInfo };\n        }\n        return namespace;\n      },\n      getChildHostContext: function (parentHostContext, type) {\n        {\n          var parentHostContextDev = parentHostContext;\n          var _namespace = getChildNamespace(parentHostContextDev.namespace, type);\n          var _ancestorInfo2 = updatedAncestorInfo(parentHostContextDev.ancestorInfo, type, null);\n          return { namespace: _namespace, ancestorInfo: _ancestorInfo2 };\n        }\n        var parentNamespace = parentHostContext;\n        return getChildNamespace(parentNamespace, type);\n      },\n      getPublicInstance: function (instance) {\n        return instance;\n      },\n      prepareForCommit: function () {\n        eventsEnabled = isEnabled();\n        selectionInformation = getSelectionInformation();\n        setEnabled(false);\n      },\n      resetAfterCommit: function () {\n        restoreSelection(selectionInformation);\n        selectionInformation = null;\n        setEnabled(eventsEnabled);\n        eventsEnabled = null;\n      },\n      createInstance: function (type, props, rootContainerInstance, hostContext, internalInstanceHandle) {\n        var parentNamespace = void 0;\n        {\n          // TODO: take namespace into account when validating.\n          var hostContextDev = hostContext;\n          validateDOMNesting$1(type, null, hostContextDev.ancestorInfo);\n          if (typeof props.children === 'string' || typeof props.children === 'number') {\n            var string = '' + props.children;\n            var ownAncestorInfo = updatedAncestorInfo(hostContextDev.ancestorInfo, type, null);\n            validateDOMNesting$1(null, string, ownAncestorInfo);\n          }\n          parentNamespace = hostContextDev.namespace;\n        }\n        var domElement = createElement(type, props, rootContainerInstance, parentNamespace);\n        precacheFiberNode(internalInstanceHandle, domElement);\n        updateFiberProps(domElement, props);\n        return domElement;\n      },\n      appendInitialChild: function (parentInstance, child) {\n        parentInstance.appendChild(child);\n      },\n      finalizeInitialChildren: function (domElement, type, props, rootContainerInstance) {\n        setInitialProperties(domElement, type, props, rootContainerInstance);\n        return shouldAutoFocusHostComponent(type, props);\n      },\n      prepareUpdate: function (domElement, type, oldProps, newProps, rootContainerInstance, hostContext) {\n        {\n          var hostContextDev = hostContext;\n          if (typeof newProps.children !== typeof oldProps.children && (typeof newProps.children === 'string' || typeof newProps.children === 'number')) {\n            var string = '' + newProps.children;\n            var ownAncestorInfo = updatedAncestorInfo(hostContextDev.ancestorInfo, type, null);\n            validateDOMNesting$1(null, string, ownAncestorInfo);\n          }\n        }\n        return diffProperties(domElement, type, oldProps, newProps, rootContainerInstance);\n      },\n      shouldSetTextContent: function (type, props) {\n        return type === 'textarea' || typeof props.children === 'string' || typeof props.children === 'number' || typeof props.dangerouslySetInnerHTML === 'object' && props.dangerouslySetInnerHTML !== null && typeof props.dangerouslySetInnerHTML.__html === 'string';\n      },\n      shouldDeprioritizeSubtree: function (type, props) {\n        return !!props.hidden;\n      },\n      createTextInstance: function (text, rootContainerInstance, hostContext, internalInstanceHandle) {\n        {\n          var hostContextDev = hostContext;\n          validateDOMNesting$1(null, text, hostContextDev.ancestorInfo);\n        }\n        var textNode = createTextNode(text, rootContainerInstance);\n        precacheFiberNode(internalInstanceHandle, textNode);\n        return textNode;\n      },\n\n      now: now,\n\n      mutation: {\n        commitMount: function (domElement, type, newProps, internalInstanceHandle) {\n          domElement.focus();\n        },\n        commitUpdate: function (domElement, updatePayload, type, oldProps, newProps, internalInstanceHandle) {\n          // Update the props handle so that we know which props are the ones with\n          // with current event handlers.\n          updateFiberProps(domElement, newProps);\n          // Apply the diff to the DOM node.\n          updateProperties(domElement, updatePayload, type, oldProps, newProps);\n        },\n        resetTextContent: function (domElement) {\n          domElement.textContent = '';\n        },\n        commitTextUpdate: function (textInstance, oldText, newText) {\n          textInstance.nodeValue = newText;\n        },\n        appendChild: function (parentInstance, child) {\n          parentInstance.appendChild(child);\n        },\n        appendChildToContainer: function (container, child) {\n          if (container.nodeType === COMMENT_NODE) {\n            container.parentNode.insertBefore(child, container);\n          } else {\n            container.appendChild(child);\n          }\n        },\n        insertBefore: function (parentInstance, child, beforeChild) {\n          parentInstance.insertBefore(child, beforeChild);\n        },\n        insertInContainerBefore: function (container, child, beforeChild) {\n          if (container.nodeType === COMMENT_NODE) {\n            container.parentNode.insertBefore(child, beforeChild);\n          } else {\n            container.insertBefore(child, beforeChild);\n          }\n        },\n        removeChild: function (parentInstance, child) {\n          parentInstance.removeChild(child);\n        },\n        removeChildFromContainer: function (container, child) {\n          if (container.nodeType === COMMENT_NODE) {\n            container.parentNode.removeChild(child);\n          } else {\n            container.removeChild(child);\n          }\n        }\n      },\n\n      hydration: {\n        canHydrateInstance: function (instance, type, props) {\n          if (instance.nodeType !== ELEMENT_NODE || type.toLowerCase() !== instance.nodeName.toLowerCase()) {\n            return null;\n          }\n          // This has now been refined to an element node.\n          return instance;\n        },\n        canHydrateTextInstance: function (instance, text) {\n          if (text === '' || instance.nodeType !== TEXT_NODE) {\n            // Empty strings are not parsed by HTML so there won't be a correct match here.\n            return null;\n          }\n          // This has now been refined to a text node.\n          return instance;\n        },\n        getNextHydratableSibling: function (instance) {\n          var node = instance.nextSibling;\n          // Skip non-hydratable nodes.\n          while (node && node.nodeType !== ELEMENT_NODE && node.nodeType !== TEXT_NODE) {\n            node = node.nextSibling;\n          }\n          return node;\n        },\n        getFirstHydratableChild: function (parentInstance) {\n          var next = parentInstance.firstChild;\n          // Skip non-hydratable nodes.\n          while (next && next.nodeType !== ELEMENT_NODE && next.nodeType !== TEXT_NODE) {\n            next = next.nextSibling;\n          }\n          return next;\n        },\n        hydrateInstance: function (instance, type, props, rootContainerInstance, hostContext, internalInstanceHandle) {\n          precacheFiberNode(internalInstanceHandle, instance);\n          // TODO: Possibly defer this until the commit phase where all the events\n          // get attached.\n          updateFiberProps(instance, props);\n          var parentNamespace = void 0;\n          {\n            var hostContextDev = hostContext;\n            parentNamespace = hostContextDev.namespace;\n          }\n          return diffHydratedProperties(instance, type, props, parentNamespace, rootContainerInstance);\n        },\n        hydrateTextInstance: function (textInstance, text, internalInstanceHandle) {\n          precacheFiberNode(internalInstanceHandle, textInstance);\n          return diffHydratedText(textInstance, text);\n        },\n        didNotMatchHydratedContainerTextInstance: function (parentContainer, textInstance, text) {\n          {\n            warnForUnmatchedText(textInstance, text);\n          }\n        },\n        didNotMatchHydratedTextInstance: function (parentType, parentProps, parentInstance, textInstance, text) {\n          if (true && parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            warnForUnmatchedText(textInstance, text);\n          }\n        },\n        didNotHydrateContainerInstance: function (parentContainer, instance) {\n          {\n            if (instance.nodeType === 1) {\n              warnForDeletedHydratableElement(parentContainer, instance);\n            } else {\n              warnForDeletedHydratableText(parentContainer, instance);\n            }\n          }\n        },\n        didNotHydrateInstance: function (parentType, parentProps, parentInstance, instance) {\n          if (true && parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            if (instance.nodeType === 1) {\n              warnForDeletedHydratableElement(parentInstance, instance);\n            } else {\n              warnForDeletedHydratableText(parentInstance, instance);\n            }\n          }\n        },\n        didNotFindHydratableContainerInstance: function (parentContainer, type, props) {\n          {\n            warnForInsertedHydratedElement(parentContainer, type, props);\n          }\n        },\n        didNotFindHydratableContainerTextInstance: function (parentContainer, text) {\n          {\n            warnForInsertedHydratedText(parentContainer, text);\n          }\n        },\n        didNotFindHydratableInstance: function (parentType, parentProps, parentInstance, type, props) {\n          if (true && parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            warnForInsertedHydratedElement(parentInstance, type, props);\n          }\n        },\n        didNotFindHydratableTextInstance: function (parentType, parentProps, parentInstance, text) {\n          if (true && parentProps[SUPPRESS_HYDRATION_WARNING] !== true) {\n            warnForInsertedHydratedText(parentInstance, text);\n          }\n        }\n      },\n\n      scheduleDeferredCallback: rIC,\n      cancelDeferredCallback: cIC,\n\n      useSyncScheduling: !enableAsyncSchedulingByDefaultInReactDOM\n    });\n\n    injection$4.injectFiberBatchedUpdates(DOMRenderer.batchedUpdates);\n\n    var warnedAboutHydrateAPI = false;\n\n    function renderSubtreeIntoContainer(parentComponent, children, container, forceHydrate, callback) {\n      !isValidContainer(container) ? invariant(false, 'Target container is not a DOM element.') : void 0;\n\n      {\n        if (container._reactRootContainer && container.nodeType !== COMMENT_NODE) {\n          var hostInstance = DOMRenderer.findHostInstanceWithNoPortals(container._reactRootContainer.current);\n          if (hostInstance) {\n            warning(hostInstance.parentNode === container, 'render(...): It looks like the React-rendered content of this ' + 'container was removed without using React. This is not ' + 'supported and will cause errors. Instead, call ' + 'ReactDOM.unmountComponentAtNode to empty a container.');\n          }\n        }\n\n        var isRootRenderedBySomeReact = !!container._reactRootContainer;\n        var rootEl = getReactRootElementInContainer(container);\n        var hasNonRootReactChild = !!(rootEl && getInstanceFromNode$1(rootEl));\n\n        warning(!hasNonRootReactChild || isRootRenderedBySomeReact, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.');\n\n        warning(container.nodeType !== ELEMENT_NODE || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.');\n      }\n\n      var root = container._reactRootContainer;\n      if (!root) {\n        var shouldHydrate = forceHydrate || shouldHydrateDueToLegacyHeuristic(container);\n        // First clear any existing content.\n        if (!shouldHydrate) {\n          var warned = false;\n          var rootSibling = void 0;\n          while (rootSibling = container.lastChild) {\n            {\n              if (!warned && rootSibling.nodeType === ELEMENT_NODE && rootSibling.hasAttribute(ROOT_ATTRIBUTE_NAME)) {\n                warned = true;\n                warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.');\n              }\n            }\n            container.removeChild(rootSibling);\n          }\n        }\n        {\n          if (shouldHydrate && !forceHydrate && !warnedAboutHydrateAPI) {\n            warnedAboutHydrateAPI = true;\n            lowPriorityWarning$1(false, 'render(): Calling ReactDOM.render() to hydrate server-rendered markup ' + 'will stop working in React v17. Replace the ReactDOM.render() call ' + 'with ReactDOM.hydrate() if you want React to attach to the server HTML.');\n          }\n        }\n        var newRoot = DOMRenderer.createContainer(container, shouldHydrate);\n        root = container._reactRootContainer = newRoot;\n        // Initial mount should not be batched.\n        DOMRenderer.unbatchedUpdates(function () {\n          DOMRenderer.updateContainer(children, newRoot, parentComponent, callback);\n        });\n      } else {\n        DOMRenderer.updateContainer(children, root, parentComponent, callback);\n      }\n      return DOMRenderer.getPublicRootInstance(root);\n    }\n\n    function createPortal(children, container) {\n      var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n      !isValidContainer(container) ? invariant(false, 'Target container is not a DOM element.') : void 0;\n      // TODO: pass ReactDOM portal implementation as third argument\n      return createPortal$1(children, container, null, key);\n    }\n\n    function ReactRoot(container, hydrate) {\n      var root = DOMRenderer.createContainer(container, hydrate);\n      this._reactRootContainer = root;\n    }\n    ReactRoot.prototype.render = function (children, callback) {\n      var root = this._reactRootContainer;\n      DOMRenderer.updateContainer(children, root, null, callback);\n    };\n    ReactRoot.prototype.unmount = function (callback) {\n      var root = this._reactRootContainer;\n      DOMRenderer.updateContainer(null, root, null, callback);\n    };\n\n    var ReactDOM = {\n      createPortal: createPortal,\n\n      findDOMNode: function (componentOrElement) {\n        {\n          var owner = ReactCurrentOwner.current;\n          if (owner !== null) {\n            var warnedAboutRefsInRender = owner.stateNode._warnedAboutRefsInRender;\n            warning(warnedAboutRefsInRender, '%s is accessing findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', getComponentName(owner) || 'A component');\n            owner.stateNode._warnedAboutRefsInRender = true;\n          }\n        }\n        if (componentOrElement == null) {\n          return null;\n        }\n        if (componentOrElement.nodeType === ELEMENT_NODE) {\n          return componentOrElement;\n        }\n\n        var inst = get(componentOrElement);\n        if (inst) {\n          return DOMRenderer.findHostInstance(inst);\n        }\n\n        if (typeof componentOrElement.render === 'function') {\n          invariant(false, 'Unable to find node on an unmounted component.');\n        } else {\n          invariant(false, 'Element appears to be neither ReactComponent nor DOMNode. Keys: %s', Object.keys(componentOrElement));\n        }\n      },\n      hydrate: function (element, container, callback) {\n        // TODO: throw or warn if we couldn't hydrate?\n        return renderSubtreeIntoContainer(null, element, container, true, callback);\n      },\n      render: function (element, container, callback) {\n        return renderSubtreeIntoContainer(null, element, container, false, callback);\n      },\n      unstable_renderSubtreeIntoContainer: function (parentComponent, element, containerNode, callback) {\n        !(parentComponent != null && has(parentComponent)) ? invariant(false, 'parentComponent must be a valid React Component') : void 0;\n        return renderSubtreeIntoContainer(parentComponent, element, containerNode, false, callback);\n      },\n      unmountComponentAtNode: function (container) {\n        !isValidContainer(container) ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : void 0;\n\n        if (container._reactRootContainer) {\n          {\n            var rootEl = getReactRootElementInContainer(container);\n            var renderedByDifferentReact = rootEl && !getInstanceFromNode$1(rootEl);\n            warning(!renderedByDifferentReact, \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by another copy of React.');\n          }\n\n          // Unmount should not be batched.\n          DOMRenderer.unbatchedUpdates(function () {\n            renderSubtreeIntoContainer(null, null, container, false, function () {\n              container._reactRootContainer = null;\n            });\n          });\n          // If you call unmountComponentAtNode twice in quick succession, you'll\n          // get `true` twice. That's probably fine?\n          return true;\n        } else {\n          {\n            var _rootEl = getReactRootElementInContainer(container);\n            var hasNonRootReactChild = !!(_rootEl && getInstanceFromNode$1(_rootEl));\n\n            // Check if the container itself is a React root node.\n            var isContainerReactRoot = container.nodeType === 1 && isValidContainer(container.parentNode) && !!container.parentNode._reactRootContainer;\n\n            warning(!hasNonRootReactChild, \"unmountComponentAtNode(): The node you're attempting to unmount \" + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.');\n          }\n\n          return false;\n        }\n      },\n\n      // Temporary alias since we already shipped React 16 RC with it.\n      // TODO: remove in React 17.\n      unstable_createPortal: createPortal,\n\n      unstable_batchedUpdates: batchedUpdates,\n\n      unstable_deferredUpdates: DOMRenderer.deferredUpdates,\n\n      flushSync: DOMRenderer.flushSync,\n\n      __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {\n        // For TapEventPlugin which is popular in open source\n        EventPluginHub: EventPluginHub,\n        // Used by test-utils\n        EventPluginRegistry: EventPluginRegistry,\n        EventPropagators: EventPropagators,\n        ReactControlledComponent: ReactControlledComponent,\n        ReactDOMComponentTree: ReactDOMComponentTree,\n        ReactDOMEventListener: ReactDOMEventListener\n      }\n    };\n\n    if (enableCreateRoot) {\n      ReactDOM.createRoot = function createRoot(container, options) {\n        var hydrate = options != null && options.hydrate === true;\n        return new ReactRoot(container, hydrate);\n      };\n    }\n\n    var foundDevTools = DOMRenderer.injectIntoDevTools({\n      findFiberByHostInstance: getClosestInstanceFromNode,\n      bundleType: 1,\n      version: ReactVersion,\n      rendererPackageName: 'react-dom'\n    });\n\n    {\n      if (!foundDevTools && ExecutionEnvironment.canUseDOM && window.top === window.self) {\n        // If we're in Chrome or Firefox, provide a download link if not installed.\n        if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) {\n          var protocol = window.location.protocol;\n          // Don't warn in exotic cases like chrome-extension://.\n          if (/^(https?|file):$/.test(protocol)) {\n            console.info('%cDownload the React DevTools ' + 'for a better development experience: ' + 'https://fb.me/react-devtools' + (protocol === 'file:' ? '\\nYou might need to use a local HTTP server (instead of file://): ' + 'https://fb.me/react-devtools-faq' : ''), 'font-weight:bold');\n          }\n        }\n      }\n    }\n\n    var ReactDOM$2 = Object.freeze({\n      default: ReactDOM\n    });\n\n    var ReactDOM$3 = ReactDOM$2 && ReactDOM || ReactDOM$2;\n\n    // TODO: decide on the top-level export form.\n    // This is hacky but makes it work with both Rollup and Jest.\n    var reactDom = ReactDOM$3['default'] ? ReactDOM$3['default'] : ReactDOM$3;\n\n    module.exports = reactDom;\n  })();\n}"},"hash":"554af7452df2ea6db0f516ae91bfdd00"}