From 046f600cc23ff2d4aeb57be8e5606347f19b76d2 Mon Sep 17 00:00:00 2001
From: Brian Vaughn <bvaughn@fb.com>
Date: Wed, 9 Aug 2017 12:18:46 -0700
Subject: [PATCH] React 16 beta 5 sync (5495e49...c3718c4)

Reviewed By: spicyj

Differential Revision: D5564030

fbshipit-source-id: fd3e6133df7ee8e7488a3c515ce6c783c11d9401
---
 .../Animated/src/AnimatedImplementation.js    |    5 +-
 Libraries/Renderer/REVISION                   |    2 +-
 Libraries/Renderer/ReactNativeFiber-dev.js    | 9090 ++++++++---------
 Libraries/Renderer/ReactNativeFiber-prod.js   | 2013 ++--
 Libraries/Renderer/ReactNativeStack-dev.js    | 6110 ++++++-----
 Libraries/Renderer/ReactNativeStack-prod.js   | 1892 ++--
 jest/setup.js                                 |   38 +
 package.json                                  |    8 +-
 8 files changed, 9414 insertions(+), 9744 deletions(-)

diff --git a/Libraries/Animated/src/AnimatedImplementation.js b/Libraries/Animated/src/AnimatedImplementation.js
index 100b1382bc0..1f646426fc6 100644
--- a/Libraries/Animated/src/AnimatedImplementation.js
+++ b/Libraries/Animated/src/AnimatedImplementation.js
@@ -1760,6 +1760,8 @@ function createAnimatedComponent(Component: any): any {
     _eventDetachers: Array<Function> = [];
     _setComponentRef: Function;
 
+    static __skipSetNativeProps_FOR_TESTS_ONLY = false;
+
     constructor(props: Object) {
       super(props);
       this._setComponentRef = this._setComponentRef.bind(this);
@@ -1814,7 +1816,8 @@ function createAnimatedComponent(Component: any): any {
       // need to re-render it. In this case, we have a fallback that uses
       // forceUpdate.
       var callback = () => {
-        if (this._component.setNativeProps) {
+        if (!AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY &&
+          this._component.setNativeProps) {
           if (!this._propsAnimated.__isNative) {
             this._component.setNativeProps(
               this._propsAnimated.__getAnimatedValue()
diff --git a/Libraries/Renderer/REVISION b/Libraries/Renderer/REVISION
index 0abe17731ba..41cea19495f 100644
--- a/Libraries/Renderer/REVISION
+++ b/Libraries/Renderer/REVISION
@@ -1 +1 @@
-5495e495de0bd15cd96a76ee0d7ca823cc09cc71
\ No newline at end of file
+c3718c48f01fa6c2e04bd47226061769484c951b
\ No newline at end of file
diff --git a/Libraries/Renderer/ReactNativeFiber-dev.js b/Libraries/Renderer/ReactNativeFiber-dev.js
index 3f97c870cc8..480954d339b 100644
--- a/Libraries/Renderer/ReactNativeFiber-dev.js
+++ b/Libraries/Renderer/ReactNativeFiber-dev.js
@@ -11,4698 +11,4512 @@
  */
 "use strict";
 
-var invariant = require("fbjs/lib/invariant"), warning = require("fbjs/lib/warning"), ExceptionsManager = require("ExceptionsManager");
-
-require("InitializeCore");
-
-var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), UIManager = require("UIManager"), checkPropTypes = require("prop-types/checkPropTypes"), emptyObject = require("fbjs/lib/emptyObject"), react = require("react"), shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState"), deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev"), ExecutionEnvironment = require("fbjs/lib/ExecutionEnvironment"), performanceNow = require("fbjs/lib/performanceNow"), defaultShowDialog = function(capturedError) {
-    return !0;
-}, showDialog = defaultShowDialog;
-
-function logCapturedError(capturedError) {
-    if (!1 !== showDialog(capturedError)) {
-        var componentName = capturedError.componentName, componentStack = capturedError.componentStack, error = capturedError.error, errorBoundaryName = capturedError.errorBoundaryName, errorBoundaryFound = capturedError.errorBoundaryFound, willRetry = capturedError.willRetry, message = error.message, name = error.name, stack = error.stack, errorSummary = message ? name + ": " + message : name, componentNameMessage = componentName ? "React caught an error thrown by " + componentName + "." : "React caught an error thrown by one of your components.", formattedCallStack = stack.slice(0, errorSummary.length) === errorSummary ? stack.slice(errorSummary.length) : stack;
-        formattedCallStack = formattedCallStack.trim().split("\n").map(function(line) {
-            return "\n    " + line.trim();
-        }).join();
-        var errorBoundaryMessage = void 0;
-        errorBoundaryMessage = errorBoundaryFound && errorBoundaryName ? willRetry ? "React will try to recreate this component tree from scratch " + "using the error boundary you provided, " + errorBoundaryName + "." : "This error was initially handled by the error boundary " + errorBoundaryName + ". " + "Recreating the tree from scratch failed so React will unmount the tree." : "Consider adding an error boundary to your tree to customize error handling behavior.", 
-        console.error(componentNameMessage + " You should fix this error in your code. " + errorBoundaryMessage + "\n\n" + errorSummary + "\n\n" + "The error is located at: " + componentStack + "\n\n" + "The error was thrown at: " + formattedCallStack);
-    }
-}
-
-var injection = {
-    injectDialog: function(fn) {
-        invariant(showDialog === defaultShowDialog, "The custom dialog was already injected."), 
-        invariant("function" == typeof fn, "Injected showDialog() must be a function."), 
-        showDialog = fn;
-    }
-}, logCapturedError_1 = logCapturedError, ReactFiberErrorLogger = {
-    injection: injection,
-    logCapturedError: logCapturedError_1
-}, caughtError = null, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-    var funcArgs = Array.prototype.slice.call(arguments, 3);
-    try {
-        func.apply(context, funcArgs);
-    } catch (error) {
-        return error;
-    }
-    return null;
-};
-
-if ("undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) {
-    var fakeNode = document.createElement("react"), depth = 0;
-    invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-        depth++;
-        var thisDepth = depth, funcArgs = Array.prototype.slice.call(arguments, 3), boundFunc = function() {
-            func.apply(context, funcArgs);
-        }, fakeEventError = null, onFakeEventError = function(event) {
-            depth === thisDepth && (fakeEventError = event.error);
-        }, evtType = "react-" + (name || "invokeguardedcallback") + "-" + depth;
-        window.addEventListener("error", onFakeEventError), fakeNode.addEventListener(evtType, boundFunc, !1);
-        var evt = document.createEvent("Event");
-        return evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), fakeNode.removeEventListener(evtType, boundFunc, !1), 
-        window.removeEventListener("error", onFakeEventError), depth--, fakeEventError;
-    };
-}
-
-var rethrowCaughtError = function() {
-    if (caughtError) {
-        var error = caughtError;
-        throw caughtError = null, error;
-    }
-}, ReactErrorUtils = {
-    injection: {
-        injectErrorUtils: function(injectedErrorUtils) {
-            invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
-            invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
-        }
-    },
-    invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
-        return invokeGuardedCallback.apply(this, arguments);
-    },
-    invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
-        var error = ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
-        null !== error && null === caughtError && (caughtError = error);
-    },
-    rethrowCaughtError: function() {
-        return rethrowCaughtError.apply(this, arguments);
-    }
-}, ReactErrorUtils_1 = ReactErrorUtils, ComponentTree, injection$1 = {
-    injectComponentTree: function(Injected) {
-        ComponentTree = Injected, warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, "EventPluginUtils.injection.injectComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.");
-    }
-};
-
-function isEndish(topLevelType) {
-    return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
-}
-
-function isMoveish(topLevelType) {
-    return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
-}
-
-function isStartish(topLevelType) {
-    return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
-}
-
-var validateEventDispatches;
-
-validateEventDispatches = function(event) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances, listenersIsArr = Array.isArray(dispatchListeners), listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0, instancesIsArr = Array.isArray(dispatchInstances), instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
-    warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, "EventPluginUtils: Invalid `event`.");
-};
-
-function executeDispatch(event, simulated, listener, inst) {
-    var type = event.type || "unknown-event";
-    event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
-    event.currentTarget = null;
-}
-
-function executeDispatchesInOrder(event, simulated) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (validateEventDispatches(event), Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
-    event._dispatchListeners = null, event._dispatchInstances = null;
-}
-
-function executeDispatchesInOrderStopAtTrueImpl(event) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (validateEventDispatches(event), Array.isArray(dispatchListeners)) {
-        for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
-    } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
-    return null;
-}
-
-function executeDispatchesInOrderStopAtTrue(event) {
-    var ret = executeDispatchesInOrderStopAtTrueImpl(event);
-    return event._dispatchInstances = null, event._dispatchListeners = null, ret;
-}
-
-function executeDirectDispatch(event) {
-    validateEventDispatches(event);
-    var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
-    invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
-    event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
-    var res = dispatchListener ? dispatchListener(event) : null;
-    return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
-    res;
-}
-
-function hasDispatches(event) {
-    return !!event._dispatchListeners;
-}
-
-var EventPluginUtils = {
-    isEndish: isEndish,
-    isMoveish: isMoveish,
-    isStartish: isStartish,
-    executeDirectDispatch: executeDirectDispatch,
-    executeDispatchesInOrder: executeDispatchesInOrder,
-    executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
-    hasDispatches: hasDispatches,
-    getFiberCurrentPropsFromNode: function(node) {
-        return ComponentTree.getFiberCurrentPropsFromNode(node);
-    },
-    getInstanceFromNode: function(node) {
-        return ComponentTree.getInstanceFromNode(node);
-    },
-    getNodeFromInstance: function(node) {
-        return ComponentTree.getNodeFromInstance(node);
-    },
-    injection: injection$1
-}, EventPluginUtils_1 = EventPluginUtils, fiberHostComponent = null, ReactControlledComponentInjection = {
-    injectFiberControlledHostComponent: function(hostComponentImpl) {
-        fiberHostComponent = hostComponentImpl;
-    }
-}, restoreTarget = null, restoreQueue = null;
-
-function restoreStateOfTarget(target) {
-    var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
-    if (internalInstance) {
-        if ("number" == typeof internalInstance.tag) {
-            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "Fiber needs to be injected to handle a fiber target for controlled " + "events.");
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
-            return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
-        }
-        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component."), 
-        internalInstance.restoreControlledState();
-    }
-}
-
-var ReactControlledComponent = {
-    injection: ReactControlledComponentInjection,
-    enqueueStateRestore: function(target) {
-        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
-    },
-    restoreStateIfNeeded: function() {
-        if (restoreTarget) {
-            var target = restoreTarget, queuedTargets = restoreQueue;
-            if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
+__DEV__ && function() {
+    var invariant = require("fbjs/lib/invariant"), require$$0 = require("fbjs/lib/warning"), ExceptionsManager = require("ExceptionsManager"), emptyObject = require("fbjs/lib/emptyObject"), react = require("react"), checkPropTypes = require("prop-types/checkPropTypes"), shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState"), UIManager = require("UIManager"), deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev");
+    require("InitializeCore");
+    var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), ExecutionEnvironment = require("fbjs/lib/ExecutionEnvironment"), performanceNow = require("fbjs/lib/performanceNow"), defaultShowDialog = function(capturedError) {
+        return !0;
+    }, showDialog = defaultShowDialog;
+    function logCapturedError(capturedError) {
+        if (!1 !== showDialog(capturedError)) {
+            var componentName = (capturedError.error, capturedError.componentName), componentStack = capturedError.componentStack, errorBoundaryName = capturedError.errorBoundaryName, errorBoundaryFound = capturedError.errorBoundaryFound, willRetry = capturedError.willRetry, componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:", errorBoundaryMessage = void 0;
+            errorBoundaryMessage = errorBoundaryFound && errorBoundaryName ? willRetry ? "React will try to recreate this component tree from scratch " + "using the error boundary you provided, " + errorBoundaryName + "." : "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree." : "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "You can learn more about error boundaries at https://fb.me/react-error-boundaries.";
+            var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + errorBoundaryMessage;
+            console.error(combinedMessage);
         }
     }
-}, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
-    return fn(a, b, c, d, e);
-}, fiberBatchedUpdates = function(fn, bookkeeping) {
-    return fn(bookkeeping);
-};
-
-function performFiberBatchedUpdates(fn, bookkeeping) {
-    return fiberBatchedUpdates(fn, bookkeeping);
-}
-
-function batchedUpdates(fn, bookkeeping) {
-    return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
-}
-
-var isNestingBatched = !1;
-
-function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
-    if (isNestingBatched) return batchedUpdates(fn, bookkeeping);
-    isNestingBatched = !0;
-    try {
-        return batchedUpdates(fn, bookkeeping);
-    } finally {
-        isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
-    }
-}
-
-var ReactGenericBatchingInjection = {
-    injectStackBatchedUpdates: function(_batchedUpdates) {
-        stackBatchedUpdates = _batchedUpdates;
-    },
-    injectFiberBatchedUpdates: function(_batchedUpdates) {
-        fiberBatchedUpdates = _batchedUpdates;
-    }
-}, ReactGenericBatching = {
-    batchedUpdates: batchedUpdatesWithControlledComponents,
-    injection: ReactGenericBatchingInjection
-}, ReactGenericBatching_1 = ReactGenericBatching;
-
-function ReactNativeFiberErrorDialog(capturedError) {
-    var componentStack = capturedError.componentStack, error = capturedError.error, errorToHandle = void 0;
-    if (error instanceof Error) {
-        var message = error.message, name = error.name, summary = message ? name + ": " + message : name;
-        errorToHandle = error;
+    var injection = {
+        injectDialog: function(fn) {
+            invariant(showDialog === defaultShowDialog, "The custom dialog was already injected."), 
+            invariant("function" == typeof fn, "Injected showDialog() must be a function."), 
+            showDialog = fn;
+        }
+    }, logCapturedError_1 = logCapturedError, ReactFiberErrorLogger = {
+        injection: injection,
+        logCapturedError: logCapturedError_1
+    }, ReactErrorUtils = {
+        _caughtError: null,
+        _hasCaughtError: !1,
+        _rethrowError: null,
+        _hasRethrowError: !1,
+        injection: {
+            injectErrorUtils: function(injectedErrorUtils) {
+                invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
+                invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
+            }
+        },
+        invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
+            invokeGuardedCallback.apply(ReactErrorUtils, arguments);
+        },
+        invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
+            if (ReactErrorUtils.invokeGuardedCallback.apply(this, arguments), ReactErrorUtils.hasCaughtError()) {
+                var error = ReactErrorUtils.clearCaughtError();
+                ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
+            }
+        },
+        rethrowCaughtError: function() {
+            return rethrowCaughtError.apply(ReactErrorUtils, arguments);
+        },
+        hasCaughtError: function() {
+            return ReactErrorUtils._hasCaughtError;
+        },
+        clearCaughtError: function() {
+            if (ReactErrorUtils._hasCaughtError) {
+                var error = ReactErrorUtils._caughtError;
+                return ReactErrorUtils._caughtError = null, ReactErrorUtils._hasCaughtError = !1, 
+                error;
+            }
+            invariant(!1, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
+        }
+    }, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+        ReactErrorUtils._hasCaughtError = !1, ReactErrorUtils._caughtError = null;
+        var funcArgs = Array.prototype.slice.call(arguments, 3);
         try {
-            errorToHandle.message = summary + "\n\nThis error is located at:" + componentStack;
-        } catch (e) {}
-    } else errorToHandle = "string" == typeof error ? new Error(error + "\n\nThis error is located at:" + componentStack) : new Error("Unspecified error at:" + componentStack);
-    return ExceptionsManager.handleException(errorToHandle, !1), !1;
-}
-
-var showDialog$1 = ReactNativeFiberErrorDialog, ReactNativeFiberErrorDialog_1 = {
-    showDialog: showDialog$1
-}, eventPluginOrder = null, namesToPlugins = {};
-
-function recomputePluginOrdering() {
-    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
-        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
-        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
-        !EventPluginRegistry.plugins[pluginIndex]) {
-            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
-            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
-            var publishedEvents = pluginModule.eventTypes;
-            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
+            func.apply(context, funcArgs);
+        } catch (error) {
+            ReactErrorUtils._caughtError = error, ReactErrorUtils._hasCaughtError = !0;
+        }
+    };
+    if ("undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) {
+        var fakeNode = document.createElement("react");
+        invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+            var didError = !0, funcArgs = Array.prototype.slice.call(arguments, 3);
+            function callCallback() {
+                fakeNode.removeEventListener(evtType, callCallback, !1), func.apply(context, funcArgs), 
+                didError = !1;
+            }
+            var error = void 0, didSetError = !1, isCrossOriginError = !1;
+            function onError(event) {
+                error = event.error, didSetError = !0, null === error && 0 === event.colno && 0 === event.lineno && (isCrossOriginError = !0);
+            }
+            var evtType = "react-" + (name || "invokeguardedcallback");
+            window.addEventListener("error", onError), fakeNode.addEventListener(evtType, callCallback, !1);
+            var evt = document.createEvent("Event");
+            evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), didError ? (didSetError ? isCrossOriginError && (error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error because it catches errors using a global " + 'error handler, in order to preserve the "Pause on exceptions" ' + "behavior of the DevTools. This is only an issue in DEV-mode; " + "in production, React uses a normal try-catch statement.\n\n" + "If you are using React from a CDN, ensure that the <script> tag " + "has a `crossorigin` attribute, and that it is served with the " + "`Access-Control-Allow-Origin: *` HTTP header. " + "See https://fb.me/react-cdn-crossorigin")) : 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."), 
+            ReactErrorUtils._hasCaughtError = !0, ReactErrorUtils._caughtError = error) : (ReactErrorUtils._hasCaughtError = !1, 
+            ReactErrorUtils._caughtError = null), window.removeEventListener("error", onError);
+        };
+    }
+    var ComponentTree, rethrowCaughtError = function() {
+        if (ReactErrorUtils._hasRethrowError) {
+            var error = ReactErrorUtils._rethrowError;
+            throw ReactErrorUtils._rethrowError = null, ReactErrorUtils._hasRethrowError = !1, 
+            error;
+        }
+    }, ReactErrorUtils_1 = ReactErrorUtils, warning = require$$0, injection$1 = {
+        injectComponentTree: function(Injected) {
+            ComponentTree = Injected, warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, "EventPluginUtils.injection.injectComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.");
+        }
+    };
+    function isEndish(topLevelType) {
+        return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
+    }
+    function isMoveish(topLevelType) {
+        return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
+    }
+    function isStartish(topLevelType) {
+        return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
+    }
+    var validateEventDispatches;
+    validateEventDispatches = function(event) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances, listenersIsArr = Array.isArray(dispatchListeners), listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0, instancesIsArr = Array.isArray(dispatchInstances), instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+        warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, "EventPluginUtils: Invalid `event`.");
+    };
+    function executeDispatch(event, simulated, listener, inst) {
+        var type = event.type || "unknown-event";
+        event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
+        event.currentTarget = null;
+    }
+    function executeDispatchesInOrder(event, simulated) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+        if (validateEventDispatches(event), Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
+        event._dispatchListeners = null, event._dispatchInstances = null;
+    }
+    function executeDispatchesInOrderStopAtTrueImpl(event) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+        if (validateEventDispatches(event), Array.isArray(dispatchListeners)) {
+            for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
+        } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
+        return null;
+    }
+    function executeDispatchesInOrderStopAtTrue(event) {
+        var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+        return event._dispatchInstances = null, event._dispatchListeners = null, ret;
+    }
+    function executeDirectDispatch(event) {
+        validateEventDispatches(event);
+        var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
+        invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
+        event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
+        var res = dispatchListener ? dispatchListener(event) : null;
+        return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
+        res;
+    }
+    function hasDispatches(event) {
+        return !!event._dispatchListeners;
+    }
+    var EventPluginUtils = {
+        isEndish: isEndish,
+        isMoveish: isMoveish,
+        isStartish: isStartish,
+        executeDirectDispatch: executeDirectDispatch,
+        executeDispatchesInOrder: executeDispatchesInOrder,
+        executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
+        hasDispatches: hasDispatches,
+        getFiberCurrentPropsFromNode: function(node) {
+            return ComponentTree.getFiberCurrentPropsFromNode(node);
+        },
+        getInstanceFromNode: function(node) {
+            return ComponentTree.getInstanceFromNode(node);
+        },
+        getNodeFromInstance: function(node) {
+            return ComponentTree.getNodeFromInstance(node);
+        },
+        injection: injection$1
+    }, EventPluginUtils_1 = EventPluginUtils, fiberHostComponent = null, ReactControlledComponentInjection = {
+        injectFiberControlledHostComponent: function(hostComponentImpl) {
+            fiberHostComponent = hostComponentImpl;
+        }
+    }, restoreTarget = null, restoreQueue = null;
+    function restoreStateOfTarget(target) {
+        var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
+        if (internalInstance) {
+            if ("number" == typeof internalInstance.tag) {
+                invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "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.");
+                var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
+                return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+            }
+            invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component. " + "This error is likely caused by a bug in React. Please file an issue."), 
+            internalInstance.restoreControlledState();
         }
     }
-}
+    var ReactControlledComponent = {
+        injection: ReactControlledComponentInjection,
+        enqueueStateRestore: function(target) {
+            restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
+        },
+        restoreStateIfNeeded: function() {
+            if (restoreTarget) {
+                var target = restoreTarget, queuedTargets = restoreQueue;
+                if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
+            }
+        }
+    }, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
+        return fn(a, b, c, d, e);
+    }, fiberBatchedUpdates = function(fn, bookkeeping) {
+        return fn(bookkeeping);
+    };
+    function performFiberBatchedUpdates(fn, bookkeeping) {
+        return fiberBatchedUpdates(fn, bookkeeping);
+    }
+    function batchedUpdates(fn, bookkeeping) {
+        return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
+    }
+    var isNestingBatched = !1;
+    function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
+        if (isNestingBatched) return batchedUpdates(fn, bookkeeping);
+        isNestingBatched = !0;
+        try {
+            return batchedUpdates(fn, bookkeeping);
+        } finally {
+            isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
+        }
+    }
+    var ReactGenericBatchingInjection = {
+        injectStackBatchedUpdates: function(_batchedUpdates) {
+            stackBatchedUpdates = _batchedUpdates;
+        },
+        injectFiberBatchedUpdates: function(_batchedUpdates) {
+            fiberBatchedUpdates = _batchedUpdates;
+        }
+    }, ReactGenericBatching = {
+        batchedUpdates: batchedUpdatesWithControlledComponents,
+        injection: ReactGenericBatchingInjection
+    }, ReactGenericBatching_1 = ReactGenericBatching;
+    function ReactNativeFiberErrorDialog(capturedError) {
+        var componentStack = capturedError.componentStack, error = capturedError.error, errorToHandle = void 0;
+        if (error instanceof Error) {
+            var message = error.message, name = error.name, summary = message ? name + ": " + message : name;
+            errorToHandle = error;
+            try {
+                errorToHandle.message = summary + "\n\nThis error is located at:" + componentStack;
+            } catch (e) {}
+        } else errorToHandle = "string" == typeof error ? new Error(error + "\n\nThis error is located at:" + componentStack) : new Error("Unspecified error at:" + componentStack);
+        return ExceptionsManager.handleException(errorToHandle, !1), !1;
+    }
+    var showDialog$1 = ReactNativeFiberErrorDialog, ReactNativeFiberErrorDialog_1 = {
+        showDialog: showDialog$1
+    }, REACT_PORTAL_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.portal") || 60106, createPortal = function(children, containerInfo, implementation) {
+        var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null;
+        return {
+            $$typeof: REACT_PORTAL_TYPE,
+            key: null == key ? null : "" + key,
+            children: children,
+            containerInfo: containerInfo,
+            implementation: implementation
+        };
+    }, isPortal = function(object) {
+        return "object" == typeof object && null !== object && object.$$typeof === REACT_PORTAL_TYPE;
+    }, REACT_PORTAL_TYPE_1 = REACT_PORTAL_TYPE, ReactPortal = {
+        createPortal: createPortal,
+        isPortal: isPortal,
+        REACT_PORTAL_TYPE: REACT_PORTAL_TYPE_1
+    }, instanceCache = {}, instanceProps = {};
+    function getRenderedHostOrTextFromComponent(component) {
+        for (var rendered; rendered = component._renderedComponent; ) component = rendered;
+        return component;
+    }
+    function precacheNode(inst, tag) {
+        var nativeInst = getRenderedHostOrTextFromComponent(inst);
+        instanceCache[tag] = nativeInst;
+    }
+    function precacheFiberNode(hostInst, tag) {
+        instanceCache[tag] = hostInst;
+    }
+    function uncacheNode(inst) {
+        var tag = inst._rootNodeID;
+        tag && delete instanceCache[tag];
+    }
+    function uncacheFiberNode(tag) {
+        delete instanceCache[tag], delete instanceProps[tag];
+    }
+    function getInstanceFromTag(tag) {
+        return instanceCache[tag] || null;
+    }
+    function getTagFromInstance(inst) {
+        var tag = "number" != typeof inst.tag ? inst._rootNodeID : inst.stateNode._nativeTag;
+        return invariant(tag, "All native instances should have a tag."), tag;
+    }
+    function getFiberCurrentPropsFromNode(stateNode) {
+        return instanceProps[stateNode._nativeTag] || null;
+    }
+    function updateFiberProps(tag, props) {
+        instanceProps[tag] = props;
+    }
+    var ReactNativeComponentTree = {
+        getClosestInstanceFromNode: getInstanceFromTag,
+        getInstanceFromNode: getInstanceFromTag,
+        getNodeFromInstance: getTagFromInstance,
+        precacheFiberNode: precacheFiberNode,
+        precacheNode: precacheNode,
+        uncacheFiberNode: uncacheFiberNode,
+        uncacheNode: uncacheNode,
+        getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
+        updateFiberProps: updateFiberProps
+    }, ReactNativeComponentTree_1 = ReactNativeComponentTree, commonjsGlobal = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {}, ReactFeatureFlags = {
+        disableNewFiberFeatures: !1,
+        enableAsyncSubtreeAPI: !1
+    }, ReactFeatureFlags_1 = ReactFeatureFlags, ReactTypeOfSideEffect = {
+        NoEffect: 0,
+        PerformedWork: 1,
+        Placement: 2,
+        Update: 4,
+        PlacementAndUpdate: 6,
+        Deletion: 8,
+        ContentReset: 16,
+        Callback: 32,
+        Err: 64,
+        Ref: 128
+    }, ReactPriorityLevel = {
+        NoWork: 0,
+        SynchronousPriority: 1,
+        TaskPriority: 2,
+        HighPriority: 3,
+        LowPriority: 4,
+        OffscreenPriority: 5
+    }, ReactTypeOfWork = {
+        IndeterminateComponent: 0,
+        FunctionalComponent: 1,
+        ClassComponent: 2,
+        HostRoot: 3,
+        HostPortal: 4,
+        HostComponent: 5,
+        HostText: 6,
+        CoroutineComponent: 7,
+        CoroutineHandlerPhase: 8,
+        YieldComponent: 9,
+        Fragment: 10
+    }, CallbackEffect = ReactTypeOfSideEffect.Callback, NoWork = ReactPriorityLevel.NoWork, SynchronousPriority = ReactPriorityLevel.SynchronousPriority, TaskPriority = ReactPriorityLevel.TaskPriority, ClassComponent = ReactTypeOfWork.ClassComponent, HostRoot = ReactTypeOfWork.HostRoot, warning$2 = require$$0;
+    function comparePriority(a, b) {
+        return a !== TaskPriority && a !== SynchronousPriority || b !== TaskPriority && b !== SynchronousPriority ? a === NoWork && b !== NoWork ? -255 : a !== NoWork && b === NoWork ? 255 : a - b : 0;
+    }
+    function createUpdateQueue() {
+        var queue = {
+            first: null,
+            last: null,
+            hasForceUpdate: !1,
+            callbackList: null
+        };
+        return queue.isProcessing = !1, queue;
+    }
+    function cloneUpdate(update) {
+        return {
+            priorityLevel: update.priorityLevel,
+            partialState: update.partialState,
+            callback: update.callback,
+            isReplace: update.isReplace,
+            isForced: update.isForced,
+            isTopLevelUnmount: update.isTopLevelUnmount,
+            next: null
+        };
+    }
+    function insertUpdateIntoQueue(queue, update, insertAfter, insertBefore) {
+        null !== insertAfter ? insertAfter.next = update : (update.next = queue.first, queue.first = update), 
+        null !== insertBefore ? update.next = insertBefore : queue.last = update;
+    }
+    function findInsertionPosition(queue, update) {
+        var priorityLevel = update.priorityLevel, insertAfter = null, insertBefore = null;
+        if (null !== queue.last && comparePriority(queue.last.priorityLevel, priorityLevel) <= 0) insertAfter = queue.last; else for (insertBefore = queue.first; null !== insertBefore && comparePriority(insertBefore.priorityLevel, priorityLevel) <= 0; ) insertAfter = insertBefore, 
+        insertBefore = insertBefore.next;
+        return insertAfter;
+    }
+    function ensureUpdateQueues(fiber) {
+        var alternateFiber = fiber.alternate, queue1 = fiber.updateQueue;
+        null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue());
+        var queue2 = void 0;
+        return null !== alternateFiber ? null === (queue2 = alternateFiber.updateQueue) && (queue2 = alternateFiber.updateQueue = createUpdateQueue()) : queue2 = null, 
+        [ queue1, queue2 !== queue1 ? queue2 : null ];
+    }
+    function insertUpdate(fiber, update) {
+        var _ensureUpdateQueues = ensureUpdateQueues(fiber), queue1 = _ensureUpdateQueues[0], queue2 = _ensureUpdateQueues[1];
+        (queue1.isProcessing || null !== queue2 && queue2.isProcessing) && warning$2(!1, "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.");
+        var insertAfter1 = findInsertionPosition(queue1, update), insertBefore1 = null !== insertAfter1 ? insertAfter1.next : queue1.first;
+        if (null === queue2) return insertUpdateIntoQueue(queue1, update, insertAfter1, insertBefore1), 
+        null;
+        var insertAfter2 = findInsertionPosition(queue2, update), insertBefore2 = null !== insertAfter2 ? insertAfter2.next : queue2.first;
+        if (insertUpdateIntoQueue(queue1, update, insertAfter1, insertBefore1), insertBefore1 === insertBefore2 && null !== insertBefore1 || insertAfter1 === insertAfter2 && null !== insertAfter1) return null === insertAfter2 && (queue2.first = update), 
+        null === insertBefore2 && (queue2.last = null), null;
+        var update2 = cloneUpdate(update);
+        return insertUpdateIntoQueue(queue2, update2, insertAfter2, insertBefore2), update2;
+    }
+    function addUpdate(fiber, partialState, callback, priorityLevel) {
+        insertUpdate(fiber, {
+            priorityLevel: priorityLevel,
+            partialState: partialState,
+            callback: callback,
+            isReplace: !1,
+            isForced: !1,
+            isTopLevelUnmount: !1,
+            next: null
+        });
+    }
+    var addUpdate_1 = addUpdate;
+    function addReplaceUpdate(fiber, state, callback, priorityLevel) {
+        insertUpdate(fiber, {
+            priorityLevel: priorityLevel,
+            partialState: state,
+            callback: callback,
+            isReplace: !0,
+            isForced: !1,
+            isTopLevelUnmount: !1,
+            next: null
+        });
+    }
+    var addReplaceUpdate_1 = addReplaceUpdate;
+    function addForceUpdate(fiber, callback, priorityLevel) {
+        insertUpdate(fiber, {
+            priorityLevel: priorityLevel,
+            partialState: null,
+            callback: callback,
+            isReplace: !1,
+            isForced: !0,
+            isTopLevelUnmount: !1,
+            next: null
+        });
+    }
+    var addForceUpdate_1 = addForceUpdate;
+    function getUpdatePriority(fiber) {
+        var updateQueue = fiber.updateQueue;
+        return null === updateQueue ? NoWork : fiber.tag !== ClassComponent && fiber.tag !== HostRoot ? NoWork : null !== updateQueue.first ? updateQueue.first.priorityLevel : NoWork;
+    }
+    var getUpdatePriority_1 = getUpdatePriority;
+    function addTopLevelUpdate$1(fiber, partialState, callback, priorityLevel) {
+        var isTopLevelUnmount = null === partialState.element, update = {
+            priorityLevel: priorityLevel,
+            partialState: partialState,
+            callback: callback,
+            isReplace: !1,
+            isForced: !1,
+            isTopLevelUnmount: isTopLevelUnmount,
+            next: null
+        }, update2 = insertUpdate(fiber, update);
+        if (isTopLevelUnmount) {
+            var _ensureUpdateQueues2 = ensureUpdateQueues(fiber), queue1 = _ensureUpdateQueues2[0], queue2 = _ensureUpdateQueues2[1];
+            null !== queue1 && null !== update.next && (update.next = null, queue1.last = update), 
+            null !== queue2 && null !== update2 && null !== update2.next && (update2.next = null, 
+            queue2.last = update);
+        }
+    }
+    var addTopLevelUpdate_1 = addTopLevelUpdate$1;
+    function getStateFromUpdate(update, instance, prevState, props) {
+        var partialState = update.partialState;
+        if ("function" == typeof partialState) {
+            return partialState.call(instance, prevState, props);
+        }
+        return partialState;
+    }
+    function beginUpdateQueue(current, workInProgress, queue, instance, prevState, props, priorityLevel) {
+        if (null !== current && current.updateQueue === queue) {
+            var currentQueue = queue;
+            queue = workInProgress.updateQueue = {
+                first: currentQueue.first,
+                last: currentQueue.last,
+                callbackList: null,
+                hasForceUpdate: !1
+            };
+        }
+        queue.isProcessing = !0;
+        for (var callbackList = queue.callbackList, hasForceUpdate = queue.hasForceUpdate, state = prevState, dontMutatePrevState = !0, update = queue.first; null !== update && comparePriority(update.priorityLevel, priorityLevel) <= 0; ) {
+            queue.first = update.next, null === queue.first && (queue.last = null);
+            var _partialState = void 0;
+            update.isReplace ? (state = getStateFromUpdate(update, instance, state, props), 
+            dontMutatePrevState = !0) : (_partialState = getStateFromUpdate(update, instance, state, props)) && (state = dontMutatePrevState ? Object.assign({}, state, _partialState) : Object.assign(state, _partialState), 
+            dontMutatePrevState = !1), update.isForced && (hasForceUpdate = !0), null === update.callback || update.isTopLevelUnmount && null !== update.next || (callbackList = null !== callbackList ? callbackList : [], 
+            callbackList.push(update.callback), workInProgress.effectTag |= CallbackEffect), 
+            update = update.next;
+        }
+        return queue.callbackList = callbackList, queue.hasForceUpdate = hasForceUpdate, 
+        null !== queue.first || null !== callbackList || hasForceUpdate || (workInProgress.updateQueue = null), 
+        queue.isProcessing = !1, state;
+    }
+    var beginUpdateQueue_1 = beginUpdateQueue;
+    function commitCallbacks(finishedWork, queue, context) {
+        var callbackList = queue.callbackList;
+        if (null !== callbackList) {
+            queue.callbackList = null;
+            for (var i = 0; i < callbackList.length; i++) {
+                var _callback = callbackList[i];
+                invariant("function" == typeof _callback, "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", _callback), 
+                _callback.call(context);
+            }
+        }
+    }
+    var commitCallbacks_1 = commitCallbacks, ReactFiberUpdateQueue = {
+        addUpdate: addUpdate_1,
+        addReplaceUpdate: addReplaceUpdate_1,
+        addForceUpdate: addForceUpdate_1,
+        getUpdatePriority: getUpdatePriority_1,
+        addTopLevelUpdate: addTopLevelUpdate_1,
+        beginUpdateQueue: beginUpdateQueue_1,
+        commitCallbacks: commitCallbacks_1
+    };
+    function getComponentName$1(instanceOrFiber) {
+        if ("function" == typeof instanceOrFiber.getName) {
+            return instanceOrFiber.getName();
+        }
+        if ("number" == typeof instanceOrFiber.tag) {
+            var fiber = instanceOrFiber, type = fiber.type;
+            if ("string" == typeof type) return type;
+            if ("function" == typeof type) return type.displayName || type.name;
+        }
+        return null;
+    }
+    var getComponentName_1 = getComponentName$1, ReactInstanceMap = {
+        remove: function(key) {
+            key._reactInternalInstance = void 0;
+        },
+        get: function(key) {
+            return key._reactInternalInstance;
+        },
+        has: function(key) {
+            return void 0 !== key._reactInternalInstance;
+        },
+        set: function(key, value) {
+            key._reactInternalInstance = value;
+        }
+    }, ReactInstanceMap_1 = ReactInstanceMap, ReactInternals = react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, ReactGlobalSharedState = {
+        ReactCurrentOwner: ReactInternals.ReactCurrentOwner
+    };
+    Object.assign(ReactGlobalSharedState, {
+        ReactComponentTreeHook: ReactInternals.ReactComponentTreeHook,
+        ReactDebugCurrentFrame: ReactInternals.ReactDebugCurrentFrame
+    });
+    var ReactGlobalSharedState_1 = ReactGlobalSharedState, ReactCurrentOwner = ReactGlobalSharedState_1.ReactCurrentOwner, warning$4 = require$$0, ClassComponent$2 = ReactTypeOfWork.ClassComponent, HostComponent$1 = ReactTypeOfWork.HostComponent, HostRoot$2 = ReactTypeOfWork.HostRoot, HostPortal = ReactTypeOfWork.HostPortal, HostText = ReactTypeOfWork.HostText, NoEffect = ReactTypeOfSideEffect.NoEffect, Placement = ReactTypeOfSideEffect.Placement, MOUNTING = 1, MOUNTED = 2, UNMOUNTED = 3;
+    function isFiberMountedImpl(fiber) {
+        var node = fiber;
+        if (fiber.alternate) for (;node.return; ) node = node.return; else {
+            if ((node.effectTag & Placement) !== NoEffect) return MOUNTING;
+            for (;node.return; ) if (node = node.return, (node.effectTag & Placement) !== NoEffect) return MOUNTING;
+        }
+        return node.tag === HostRoot$2 ? MOUNTED : UNMOUNTED;
+    }
+    var isFiberMounted$1 = function(fiber) {
+        return isFiberMountedImpl(fiber) === MOUNTED;
+    }, isMounted = function(component) {
+        var owner = ReactCurrentOwner.current;
+        if (null !== owner && owner.tag === ClassComponent$2) {
+            var ownerFiber = owner, instance = ownerFiber.stateNode;
+            warning$4(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_1(ownerFiber) || "A component"), 
+            instance._warnedAboutRefsInRender = !0;
+        }
+        var fiber = ReactInstanceMap_1.get(component);
+        return !!fiber && isFiberMountedImpl(fiber) === MOUNTED;
+    };
+    function assertIsMounted(fiber) {
+        invariant(isFiberMountedImpl(fiber) === MOUNTED, "Unable to find node on an unmounted component.");
+    }
+    function findCurrentFiberUsingSlowPath(fiber) {
+        var alternate = fiber.alternate;
+        if (!alternate) {
+            var state = isFiberMountedImpl(fiber);
+            return invariant(state !== UNMOUNTED, "Unable to find node on an unmounted component."), 
+            state === MOUNTING ? null : fiber;
+        }
+        for (var a = fiber, b = alternate; !0; ) {
+            var parentA = a.return, parentB = parentA ? parentA.alternate : null;
+            if (!parentA || !parentB) break;
+            if (parentA.child === parentB.child) {
+                for (var child = parentA.child; child; ) {
+                    if (child === a) return assertIsMounted(parentA), fiber;
+                    if (child === b) return assertIsMounted(parentA), alternate;
+                    child = child.sibling;
+                }
+                invariant(!1, "Unable to find node on an unmounted component.");
+            }
+            if (a.return !== b.return) a = parentA, b = parentB; else {
+                for (var didFindChild = !1, _child = parentA.child; _child; ) {
+                    if (_child === a) {
+                        didFindChild = !0, a = parentA, b = parentB;
+                        break;
+                    }
+                    if (_child === b) {
+                        didFindChild = !0, b = parentA, a = parentB;
+                        break;
+                    }
+                    _child = _child.sibling;
+                }
+                if (!didFindChild) {
+                    for (_child = parentB.child; _child; ) {
+                        if (_child === a) {
+                            didFindChild = !0, a = parentB, b = parentA;
+                            break;
+                        }
+                        if (_child === b) {
+                            didFindChild = !0, b = parentB, a = parentA;
+                            break;
+                        }
+                        _child = _child.sibling;
+                    }
+                    invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "in React related to the return pointer. Please file an issue.");
+                }
+            }
+            invariant(a.alternate === b, "Return fibers should always be each others' alternates. " + "This error is likely caused by a bug in React. Please file an issue.");
+        }
+        return invariant(a.tag === HostRoot$2, "Unable to find node on an unmounted component."), 
+        a.stateNode.current === a ? fiber : alternate;
+    }
+    var findCurrentFiberUsingSlowPath_1 = findCurrentFiberUsingSlowPath, findCurrentHostFiber$1 = function(parent) {
+        var currentParent = findCurrentFiberUsingSlowPath(parent);
+        if (!currentParent) return null;
+        for (var node = currentParent; !0; ) {
+            if (node.tag === HostComponent$1 || node.tag === HostText) return node;
+            if (node.child) node.child.return = node, node = node.child; else {
+                if (node === currentParent) return null;
+                for (;!node.sibling; ) {
+                    if (!node.return || node.return === currentParent) return null;
+                    node = node.return;
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            }
+        }
+        return null;
+    }, findCurrentHostFiberWithNoPortals$1 = function(parent) {
+        var currentParent = findCurrentFiberUsingSlowPath(parent);
+        if (!currentParent) return null;
+        for (var node = currentParent; !0; ) {
+            if (node.tag === HostComponent$1 || node.tag === HostText) return node;
+            if (node.child && node.tag !== HostPortal) node.child.return = node, node = node.child; else {
+                if (node === currentParent) return null;
+                for (;!node.sibling; ) {
+                    if (!node.return || node.return === currentParent) return null;
+                    node = node.return;
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            }
+        }
+        return null;
+    }, ReactFiberTreeReflection = {
+        isFiberMounted: isFiberMounted$1,
+        isMounted: isMounted,
+        findCurrentFiberUsingSlowPath: findCurrentFiberUsingSlowPath_1,
+        findCurrentHostFiber: findCurrentHostFiber$1,
+        findCurrentHostFiberWithNoPortals: findCurrentHostFiberWithNoPortals$1
+    }, warning$5 = require$$0, valueStack = [], fiberStack = [], index = -1, createCursor$1 = function(defaultValue) {
+        return {
+            current: defaultValue
+        };
+    }, isEmpty = function() {
+        return -1 === index;
+    }, pop$1 = function(cursor, fiber) {
+        if (index < 0) return void warning$5(!1, "Unexpected pop.");
+        fiber !== fiberStack[index] && warning$5(!1, "Unexpected Fiber popped."), cursor.current = valueStack[index], 
+        valueStack[index] = null, fiberStack[index] = null, index--;
+    }, push$1 = function(cursor, value, fiber) {
+        index++, valueStack[index] = cursor.current, fiberStack[index] = fiber, cursor.current = value;
+    }, reset = function() {
+        for (;index > -1; ) valueStack[index] = null, fiberStack[index] = null, index--;
+    }, ReactFiberStack = {
+        createCursor: createCursor$1,
+        isEmpty: isEmpty,
+        pop: pop$1,
+        push: push$1,
+        reset: reset
+    }, describeComponentFrame = function(name, source, ownerName) {
+        return "\n    in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
+    }, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent = ReactTypeOfWork.FunctionalComponent, ClassComponent$3 = ReactTypeOfWork.ClassComponent, HostComponent$2 = ReactTypeOfWork.HostComponent;
+    function describeFiber(fiber) {
+        switch (fiber.tag) {
+          case IndeterminateComponent:
+          case FunctionalComponent:
+          case ClassComponent$3:
+          case HostComponent$2:
+            var owner = fiber._debugOwner, source = fiber._debugSource, name = getComponentName_1(fiber), ownerName = null;
+            return owner && (ownerName = getComponentName_1(owner)), describeComponentFrame(name, source, ownerName);
 
-function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
-    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
-    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-    if (phasedRegistrationNames) {
-        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
-            var phasedRegistrationName = phasedRegistrationNames[phaseName];
-            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+          default:
+            return "";
+        }
+    }
+    function getStackAddendumByWorkInProgressFiber$1(workInProgress) {
+        var info = "", node = workInProgress;
+        do {
+            info += describeFiber(node), node = node.return;
+        } while (node);
+        return info;
+    }
+    var ReactFiberComponentTreeHook = {
+        getStackAddendumByWorkInProgressFiber: getStackAddendumByWorkInProgressFiber$1
+    }, ReactDebugCurrentFrame = ReactGlobalSharedState_1.ReactDebugCurrentFrame, getComponentName$3 = getComponentName_1, _require2$1 = ReactFiberComponentTreeHook, getStackAddendumByWorkInProgressFiber = _require2$1.getStackAddendumByWorkInProgressFiber;
+    function getCurrentFiberOwnerName() {
+        var fiber = ReactDebugCurrentFiber$2.current;
+        return null === fiber ? null : null != fiber._debugOwner ? getComponentName$3(fiber._debugOwner) : null;
+    }
+    function getCurrentFiberStackAddendum() {
+        var fiber = ReactDebugCurrentFiber$2.current;
+        return null === fiber ? null : getStackAddendumByWorkInProgressFiber(fiber);
+    }
+    function resetCurrentFiber() {
+        ReactDebugCurrentFrame.getCurrentStack = null, ReactDebugCurrentFiber$2.current = null, 
+        ReactDebugCurrentFiber$2.phase = null;
+    }
+    function setCurrentFiber(fiber, phase) {
+        ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum, ReactDebugCurrentFiber$2.current = fiber, 
+        ReactDebugCurrentFiber$2.phase = phase;
+    }
+    var ReactDebugCurrentFiber$2 = {
+        current: null,
+        phase: null,
+        resetCurrentFiber: resetCurrentFiber,
+        setCurrentFiber: setCurrentFiber,
+        getCurrentFiberOwnerName: getCurrentFiberOwnerName,
+        getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
+    }, ReactDebugCurrentFiber_1 = ReactDebugCurrentFiber$2, ReactDebugFiberPerf = null, _require$2 = ReactTypeOfWork, HostRoot$3 = _require$2.HostRoot, HostComponent$3 = _require$2.HostComponent, HostText$1 = _require$2.HostText, HostPortal$1 = _require$2.HostPortal, YieldComponent = _require$2.YieldComponent, Fragment = _require$2.Fragment, getComponentName$4 = getComponentName_1, reactEmoji = "⚛", warningEmoji = "⛔", supportsUserTiming = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, currentFiber = null, currentPhase = null, currentPhaseFiber = null, isCommitting = !1, hasScheduledUpdateInCurrentCommit = !1, hasScheduledUpdateInCurrentPhase = !1, commitCountInCurrentWorkLoop = 0, effectCountInCurrentCommit = 0, labelsInCurrentCommit = new Set(), formatMarkName = function(markName) {
+        return reactEmoji + " " + markName;
+    }, formatLabel = function(label, warning) {
+        return (warning ? warningEmoji + " " : reactEmoji + " ") + label + (warning ? " Warning: " + warning : "");
+    }, beginMark = function(markName) {
+        performance.mark(formatMarkName(markName));
+    }, clearMark = function(markName) {
+        performance.clearMarks(formatMarkName(markName));
+    }, endMark = function(label, markName, warning) {
+        var formattedMarkName = formatMarkName(markName), formattedLabel = formatLabel(label, warning);
+        try {
+            performance.measure(formattedLabel, formattedMarkName);
+        } catch (err) {}
+        performance.clearMarks(formattedMarkName), performance.clearMeasures(formattedLabel);
+    }, getFiberMarkName = function(label, debugID) {
+        return label + " (#" + debugID + ")";
+    }, getFiberLabel = function(componentName, isMounted, phase) {
+        return null === phase ? componentName + " [" + (isMounted ? "update" : "mount") + "]" : componentName + "." + phase;
+    }, beginFiberMark = function(fiber, phase) {
+        var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase);
+        if (isCommitting && labelsInCurrentCommit.has(label)) return !1;
+        labelsInCurrentCommit.add(label);
+        var markName = getFiberMarkName(label, debugID);
+        return beginMark(markName), !0;
+    }, clearFiberMark = function(fiber, phase) {
+        var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase), markName = getFiberMarkName(label, debugID);
+        clearMark(markName);
+    }, endFiberMark = function(fiber, phase, warning) {
+        var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase), markName = getFiberMarkName(label, debugID);
+        endMark(label, markName, warning);
+    }, shouldIgnoreFiber = function(fiber) {
+        switch (fiber.tag) {
+          case HostRoot$3:
+          case HostComponent$3:
+          case HostText$1:
+          case HostPortal$1:
+          case YieldComponent:
+          case Fragment:
+            return !0;
+
+          default:
+            return !1;
+        }
+    }, clearPendingPhaseMeasurement = function() {
+        null !== currentPhase && null !== currentPhaseFiber && clearFiberMark(currentPhaseFiber, currentPhase), 
+        currentPhaseFiber = null, currentPhase = null, hasScheduledUpdateInCurrentPhase = !1;
+    }, pauseTimers = function() {
+        for (var fiber = currentFiber; fiber; ) fiber._debugIsCurrentlyTiming && endFiberMark(fiber, null, null), 
+        fiber = fiber.return;
+    }, resumeTimersRecursively = function(fiber) {
+        null !== fiber.return && resumeTimersRecursively(fiber.return), fiber._debugIsCurrentlyTiming && beginFiberMark(fiber, null);
+    }, resumeTimers = function() {
+        null !== currentFiber && resumeTimersRecursively(currentFiber);
+    };
+    ReactDebugFiberPerf = {
+        recordEffect: function() {
+            effectCountInCurrentCommit++;
+        },
+        recordScheduleUpdate: function() {
+            isCommitting && (hasScheduledUpdateInCurrentCommit = !0), null !== currentPhase && "componentWillMount" !== currentPhase && "componentWillReceiveProps" !== currentPhase && (hasScheduledUpdateInCurrentPhase = !0);
+        },
+        startWorkTimer: function(fiber) {
+            supportsUserTiming && !shouldIgnoreFiber(fiber) && (currentFiber = fiber, beginFiberMark(fiber, null) && (fiber._debugIsCurrentlyTiming = !0));
+        },
+        cancelWorkTimer: function(fiber) {
+            supportsUserTiming && !shouldIgnoreFiber(fiber) && (fiber._debugIsCurrentlyTiming = !1, 
+            clearFiberMark(fiber, null));
+        },
+        stopWorkTimer: function(fiber) {
+            supportsUserTiming && !shouldIgnoreFiber(fiber) && (currentFiber = fiber.return, 
+            fiber._debugIsCurrentlyTiming && (fiber._debugIsCurrentlyTiming = !1, endFiberMark(fiber, null, null)));
+        },
+        stopFailedWorkTimer: function(fiber) {
+            if (supportsUserTiming && !shouldIgnoreFiber(fiber) && (currentFiber = fiber.return, 
+            fiber._debugIsCurrentlyTiming)) {
+                fiber._debugIsCurrentlyTiming = !1;
+                endFiberMark(fiber, null, "An error was thrown inside this error boundary");
+            }
+        },
+        startPhaseTimer: function(fiber, phase) {
+            supportsUserTiming && (clearPendingPhaseMeasurement(), beginFiberMark(fiber, phase) && (currentPhaseFiber = fiber, 
+            currentPhase = phase));
+        },
+        stopPhaseTimer: function() {
+            if (supportsUserTiming) {
+                if (null !== currentPhase && null !== currentPhaseFiber) {
+                    endFiberMark(currentPhaseFiber, currentPhase, hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null);
+                }
+                currentPhase = null, currentPhaseFiber = null;
+            }
+        },
+        startWorkLoopTimer: function() {
+            supportsUserTiming && (commitCountInCurrentWorkLoop = 0, beginMark("(React Tree Reconciliation)"), 
+            resumeTimers());
+        },
+        stopWorkLoopTimer: function() {
+            if (supportsUserTiming) {
+                var warning = commitCountInCurrentWorkLoop > 1 ? "There were cascading updates" : null;
+                commitCountInCurrentWorkLoop = 0, pauseTimers(), endMark("(React Tree Reconciliation)", "(React Tree Reconciliation)", warning);
+            }
+        },
+        startCommitTimer: function() {
+            supportsUserTiming && (isCommitting = !0, hasScheduledUpdateInCurrentCommit = !1, 
+            labelsInCurrentCommit.clear(), beginMark("(Committing Changes)"));
+        },
+        stopCommitTimer: function() {
+            if (supportsUserTiming) {
+                var warning = null;
+                hasScheduledUpdateInCurrentCommit ? warning = "Lifecycle hook scheduled a cascading update" : commitCountInCurrentWorkLoop > 0 && (warning = "Caused by a cascading update in earlier commit"), 
+                hasScheduledUpdateInCurrentCommit = !1, commitCountInCurrentWorkLoop++, isCommitting = !1, 
+                labelsInCurrentCommit.clear(), endMark("(Committing Changes)", "(Committing Changes)", warning);
+            }
+        },
+        startCommitHostEffectsTimer: function() {
+            supportsUserTiming && (effectCountInCurrentCommit = 0, beginMark("(Committing Host Effects)"));
+        },
+        stopCommitHostEffectsTimer: function() {
+            if (supportsUserTiming) {
+                var count = effectCountInCurrentCommit;
+                effectCountInCurrentCommit = 0, endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
+            }
+        },
+        startCommitLifeCyclesTimer: function() {
+            supportsUserTiming && (effectCountInCurrentCommit = 0, beginMark("(Calling Lifecycle Methods)"));
+        },
+        stopCommitLifeCyclesTimer: function() {
+            if (supportsUserTiming) {
+                var count = effectCountInCurrentCommit;
+                effectCountInCurrentCommit = 0, endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
+            }
+        }
+    };
+    var ReactDebugFiberPerf_1 = ReactDebugFiberPerf, isFiberMounted = ReactFiberTreeReflection.isFiberMounted, ClassComponent$1 = ReactTypeOfWork.ClassComponent, HostRoot$1 = ReactTypeOfWork.HostRoot, createCursor = ReactFiberStack.createCursor, pop = ReactFiberStack.pop, push = ReactFiberStack.push, warning$3 = require$$0, checkPropTypes$1 = checkPropTypes, ReactDebugCurrentFiber$1 = ReactDebugCurrentFiber_1, _require4 = ReactDebugFiberPerf_1, startPhaseTimer = _require4.startPhaseTimer, stopPhaseTimer = _require4.stopPhaseTimer, warnedAboutMissingGetChildContext = {}, contextStackCursor = createCursor(emptyObject), didPerformWorkStackCursor = createCursor(!1), previousContext = emptyObject;
+    function getUnmaskedContext(workInProgress) {
+        return isContextProvider$1(workInProgress) ? previousContext : contextStackCursor.current;
+    }
+    var getUnmaskedContext_1 = getUnmaskedContext;
+    function cacheContext(workInProgress, unmaskedContext, maskedContext) {
+        var instance = workInProgress.stateNode;
+        instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
+    }
+    var cacheContext_1 = cacheContext, getMaskedContext = function(workInProgress, unmaskedContext) {
+        var type = workInProgress.type, contextTypes = type.contextTypes;
+        if (!contextTypes) return emptyObject;
+        var instance = workInProgress.stateNode;
+        if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
+        var context = {};
+        for (var key in contextTypes) context[key] = unmaskedContext[key];
+        var name = getComponentName_1(workInProgress) || "Unknown";
+        return ReactDebugCurrentFiber$1.setCurrentFiber(workInProgress, null), checkPropTypes$1(contextTypes, context, "context", name, ReactDebugCurrentFiber$1.getCurrentFiberStackAddendum), 
+        ReactDebugCurrentFiber$1.resetCurrentFiber(), instance && cacheContext(workInProgress, unmaskedContext, context), 
+        context;
+    }, hasContextChanged = function() {
+        return didPerformWorkStackCursor.current;
+    };
+    function isContextConsumer(fiber) {
+        return fiber.tag === ClassComponent$1 && null != fiber.type.contextTypes;
+    }
+    var isContextConsumer_1 = isContextConsumer;
+    function isContextProvider$1(fiber) {
+        return fiber.tag === ClassComponent$1 && null != fiber.type.childContextTypes;
+    }
+    var isContextProvider_1 = isContextProvider$1;
+    function popContextProvider(fiber) {
+        isContextProvider$1(fiber) && (pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber));
+    }
+    var popContextProvider_1 = popContextProvider, pushTopLevelContextObject = function(fiber, context, didChange) {
+        invariant(null == contextStackCursor.cursor, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue."), 
+        push(contextStackCursor, context, fiber), push(didPerformWorkStackCursor, didChange, fiber);
+    };
+    function processChildContext$1(fiber, parentContext, isReconciling) {
+        var instance = fiber.stateNode, childContextTypes = fiber.type.childContextTypes;
+        if ("function" != typeof instance.getChildContext) {
+            var componentName = getComponentName_1(fiber) || "Unknown";
+            return warnedAboutMissingGetChildContext[componentName] || (warnedAboutMissingGetChildContext[componentName] = !0, 
+            warning$3(!1, "%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)), 
+            parentContext;
+        }
+        var childContext = void 0;
+        ReactDebugCurrentFiber$1.setCurrentFiber(fiber, "getChildContext"), startPhaseTimer(fiber, "getChildContext"), 
+        childContext = instance.getChildContext(), stopPhaseTimer(), ReactDebugCurrentFiber$1.resetCurrentFiber();
+        for (var contextKey in childContext) invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName_1(fiber) || "Unknown", contextKey);
+        var name = getComponentName_1(fiber) || "Unknown", workInProgress = isReconciling ? fiber : null;
+        return ReactDebugCurrentFiber$1.setCurrentFiber(workInProgress, null), checkPropTypes$1(childContextTypes, childContext, "child context", name, ReactDebugCurrentFiber$1.getCurrentFiberStackAddendum), 
+        ReactDebugCurrentFiber$1.resetCurrentFiber(), Object.assign({}, parentContext, childContext);
+    }
+    var processChildContext_1 = processChildContext$1, pushContextProvider = function(workInProgress) {
+        if (!isContextProvider$1(workInProgress)) return !1;
+        var instance = workInProgress.stateNode, memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
+        return previousContext = contextStackCursor.current, push(contextStackCursor, memoizedMergedChildContext, workInProgress), 
+        push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress), 
+        !0;
+    }, invalidateContextProvider = function(workInProgress, didChange) {
+        var instance = workInProgress.stateNode;
+        if (invariant(instance, "Expected to have an instance by this point. " + "This error is likely caused by a bug in React. Please file an issue."), 
+        didChange) {
+            var mergedContext = processChildContext$1(workInProgress, previousContext, !0);
+            instance.__reactInternalMemoizedMergedChildContext = mergedContext, pop(didPerformWorkStackCursor, workInProgress), 
+            pop(contextStackCursor, workInProgress), push(contextStackCursor, mergedContext, workInProgress), 
+            push(didPerformWorkStackCursor, didChange, workInProgress);
+        } else pop(didPerformWorkStackCursor, workInProgress), push(didPerformWorkStackCursor, didChange, workInProgress);
+    }, resetContext = function() {
+        previousContext = emptyObject, contextStackCursor.current = emptyObject, didPerformWorkStackCursor.current = !1;
+    }, findCurrentUnmaskedContext$1 = function(fiber) {
+        invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent$1, "Expected subtree parent to be a mounted class component. " + "This error is likely caused by a bug in React. Please file an issue.");
+        for (var node = fiber; node.tag !== HostRoot$1; ) {
+            if (isContextProvider$1(node)) return node.stateNode.__reactInternalMemoizedMergedChildContext;
+            var parent = node.return;
+            invariant(parent, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue."), 
+            node = parent;
+        }
+        return node.stateNode.context;
+    }, ReactFiberContext = {
+        getUnmaskedContext: getUnmaskedContext_1,
+        cacheContext: cacheContext_1,
+        getMaskedContext: getMaskedContext,
+        hasContextChanged: hasContextChanged,
+        isContextConsumer: isContextConsumer_1,
+        isContextProvider: isContextProvider_1,
+        popContextProvider: popContextProvider_1,
+        pushTopLevelContextObject: pushTopLevelContextObject,
+        processChildContext: processChildContext_1,
+        pushContextProvider: pushContextProvider,
+        invalidateContextProvider: invalidateContextProvider,
+        resetContext: resetContext,
+        findCurrentUnmaskedContext: findCurrentUnmaskedContext$1
+    }, ReactTypeOfInternalContext = {
+        NoContext: 0,
+        AsyncUpdates: 1
+    }, IndeterminateComponent$1 = ReactTypeOfWork.IndeterminateComponent, ClassComponent$4 = ReactTypeOfWork.ClassComponent, HostRoot$4 = ReactTypeOfWork.HostRoot, HostComponent$4 = ReactTypeOfWork.HostComponent, HostText$2 = ReactTypeOfWork.HostText, HostPortal$2 = ReactTypeOfWork.HostPortal, CoroutineComponent = ReactTypeOfWork.CoroutineComponent, YieldComponent$1 = ReactTypeOfWork.YieldComponent, Fragment$1 = ReactTypeOfWork.Fragment, NoWork$1 = ReactPriorityLevel.NoWork, NoContext = ReactTypeOfInternalContext.NoContext, NoEffect$1 = ReactTypeOfSideEffect.NoEffect, getComponentName$5 = getComponentName_1, hasBadMapPolyfill = !1;
+    try {
+        var nonExtensibleObject = Object.preventExtensions({});
+        new Map([ [ nonExtensibleObject, null ] ]), new Set([ nonExtensibleObject ]);
+    } catch (e) {
+        hasBadMapPolyfill = !0;
+    }
+    var debugCounter = 1, createFiber = function(tag, key, internalContextTag) {
+        var fiber = {
+            tag: tag,
+            key: key,
+            type: null,
+            stateNode: null,
+            return: null,
+            child: null,
+            sibling: null,
+            index: 0,
+            ref: null,
+            pendingProps: null,
+            memoizedProps: null,
+            updateQueue: null,
+            memoizedState: null,
+            internalContextTag: internalContextTag,
+            effectTag: NoEffect$1,
+            nextEffect: null,
+            firstEffect: null,
+            lastEffect: null,
+            pendingWorkPriority: NoWork$1,
+            alternate: null
+        };
+        return fiber._debugID = debugCounter++, fiber._debugSource = null, fiber._debugOwner = null, 
+        fiber._debugIsCurrentlyTiming = !1, hasBadMapPolyfill || "function" != typeof Object.preventExtensions || Object.preventExtensions(fiber), 
+        fiber;
+    };
+    function shouldConstruct(Component) {
+        return !(!Component.prototype || !Component.prototype.isReactComponent);
+    }
+    var createWorkInProgress = function(current, renderPriority) {
+        var workInProgress = current.alternate;
+        return null === workInProgress ? (workInProgress = createFiber(current.tag, current.key, current.internalContextTag), 
+        workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, 
+        workInProgress._debugID = current._debugID, workInProgress._debugSource = current._debugSource, 
+        workInProgress._debugOwner = current._debugOwner, workInProgress.alternate = current, 
+        current.alternate = workInProgress) : (workInProgress.effectTag = NoWork$1, workInProgress.nextEffect = null, 
+        workInProgress.firstEffect = null, workInProgress.lastEffect = null), workInProgress.pendingWorkPriority = renderPriority, 
+        workInProgress.child = current.child, workInProgress.memoizedProps = current.memoizedProps, 
+        workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, 
+        workInProgress.sibling = current.sibling, workInProgress.index = current.index, 
+        workInProgress.ref = current.ref, workInProgress;
+    }, createHostRootFiber$1 = function() {
+        return createFiber(HostRoot$4, null, NoContext);
+    }, createFiberFromElement = function(element, internalContextTag, priorityLevel) {
+        var owner = null;
+        owner = element._owner;
+        var fiber = createFiberFromElementType(element.type, element.key, internalContextTag, owner);
+        return fiber.pendingProps = element.props, fiber.pendingWorkPriority = priorityLevel, 
+        fiber._debugSource = element._source, fiber._debugOwner = element._owner, fiber;
+    }, createFiberFromFragment = function(elements, internalContextTag, priorityLevel) {
+        var fiber = createFiber(Fragment$1, null, internalContextTag);
+        return fiber.pendingProps = elements, fiber.pendingWorkPriority = priorityLevel, 
+        fiber;
+    }, createFiberFromText = function(content, internalContextTag, priorityLevel) {
+        var fiber = createFiber(HostText$2, null, internalContextTag);
+        return fiber.pendingProps = content, fiber.pendingWorkPriority = priorityLevel, 
+        fiber;
+    };
+    function createFiberFromElementType(type, key, internalContextTag, debugOwner) {
+        var fiber = void 0;
+        if ("function" == typeof type) fiber = shouldConstruct(type) ? createFiber(ClassComponent$4, key, internalContextTag) : createFiber(IndeterminateComponent$1, key, internalContextTag), 
+        fiber.type = type; else if ("string" == typeof type) fiber = createFiber(HostComponent$4, key, internalContextTag), 
+        fiber.type = type; else if ("object" == typeof type && null !== type && "number" == typeof type.tag) fiber = type; else {
+            var info = "";
+            (void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file " + "it's defined in.");
+            var ownerName = debugOwner ? getComponentName$5(debugOwner) : null;
+            ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`."), invariant(!1, "Element type is invalid: expected a string (for built-in components) " + "or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info);
+        }
+        return fiber;
+    }
+    var REACT_COROUTINE_TYPE$1, REACT_YIELD_TYPE$1, createFiberFromElementType_1 = createFiberFromElementType, createFiberFromHostInstanceForDeletion = function() {
+        var fiber = createFiber(HostComponent$4, null, NoContext);
+        return fiber.type = "DELETED", fiber;
+    }, createFiberFromCoroutine = function(coroutine, internalContextTag, priorityLevel) {
+        var fiber = createFiber(CoroutineComponent, coroutine.key, internalContextTag);
+        return fiber.type = coroutine.handler, fiber.pendingProps = coroutine, fiber.pendingWorkPriority = priorityLevel, 
+        fiber;
+    }, createFiberFromYield = function(yieldNode, internalContextTag, priorityLevel) {
+        return createFiber(YieldComponent$1, null, internalContextTag);
+    }, createFiberFromPortal = function(portal, internalContextTag, priorityLevel) {
+        var fiber = createFiber(HostPortal$2, portal.key, internalContextTag);
+        return fiber.pendingProps = portal.children || [], fiber.pendingWorkPriority = priorityLevel, 
+        fiber.stateNode = {
+            containerInfo: portal.containerInfo,
+            implementation: portal.implementation
+        }, fiber;
+    }, largerPriority = function(p1, p2) {
+        return p1 !== NoWork$1 && (p2 === NoWork$1 || p2 > p1) ? p1 : p2;
+    }, ReactFiber = {
+        createWorkInProgress: createWorkInProgress,
+        createHostRootFiber: createHostRootFiber$1,
+        createFiberFromElement: createFiberFromElement,
+        createFiberFromFragment: createFiberFromFragment,
+        createFiberFromText: createFiberFromText,
+        createFiberFromElementType: createFiberFromElementType_1,
+        createFiberFromHostInstanceForDeletion: createFiberFromHostInstanceForDeletion,
+        createFiberFromCoroutine: createFiberFromCoroutine,
+        createFiberFromYield: createFiberFromYield,
+        createFiberFromPortal: createFiberFromPortal,
+        largerPriority: largerPriority
+    }, createHostRootFiber = ReactFiber.createHostRootFiber, createFiberRoot$1 = function(containerInfo) {
+        var uninitializedFiber = createHostRootFiber(), root = {
+            current: uninitializedFiber,
+            containerInfo: containerInfo,
+            isScheduled: !1,
+            nextScheduledRoot: null,
+            context: null,
+            pendingContext: null
+        };
+        return uninitializedFiber.stateNode = root, root;
+    }, ReactFiberRoot = {
+        createFiberRoot: createFiberRoot$1
+    };
+    "function" == typeof Symbol && Symbol.for ? (REACT_COROUTINE_TYPE$1 = Symbol.for("react.coroutine"), 
+    REACT_YIELD_TYPE$1 = Symbol.for("react.yield")) : (REACT_COROUTINE_TYPE$1 = 60104, 
+    REACT_YIELD_TYPE$1 = 60105);
+    var createCoroutine = function(children, handler, props) {
+        var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null, coroutine = {
+            $$typeof: REACT_COROUTINE_TYPE$1,
+            key: null == key ? null : "" + key,
+            children: children,
+            handler: handler,
+            props: props
+        };
+        return Object.freeze && (Object.freeze(coroutine.props), Object.freeze(coroutine)), 
+        coroutine;
+    }, createYield = function(value) {
+        var yieldNode = {
+            $$typeof: REACT_YIELD_TYPE$1,
+            value: value
+        };
+        return Object.freeze && Object.freeze(yieldNode), yieldNode;
+    }, isCoroutine = function(object) {
+        return "object" == typeof object && null !== object && object.$$typeof === REACT_COROUTINE_TYPE$1;
+    }, isYield = function(object) {
+        return "object" == typeof object && null !== object && object.$$typeof === REACT_YIELD_TYPE$1;
+    }, REACT_YIELD_TYPE_1 = REACT_YIELD_TYPE$1, REACT_COROUTINE_TYPE_1 = REACT_COROUTINE_TYPE$1, ReactCoroutine = {
+        createCoroutine: createCoroutine,
+        createYield: createYield,
+        isCoroutine: isCoroutine,
+        isYield: isYield,
+        REACT_YIELD_TYPE: REACT_YIELD_TYPE_1,
+        REACT_COROUTINE_TYPE: REACT_COROUTINE_TYPE_1
+    }, REACT_COROUTINE_TYPE = ReactCoroutine.REACT_COROUTINE_TYPE, REACT_YIELD_TYPE = ReactCoroutine.REACT_YIELD_TYPE, REACT_PORTAL_TYPE$1 = ReactPortal.REACT_PORTAL_TYPE, _require3$2 = ReactDebugCurrentFiber_1, getCurrentFiberStackAddendum$1 = _require3$2.getCurrentFiberStackAddendum, warning$8 = require$$0, didWarnAboutMaps = !1, ownerHasKeyUseWarning = {}, warnForMissingKey = function(child) {
+        if (null !== child && "object" == typeof child && child._store && !child._store.validated && null == child.key) {
+            invariant("object" == typeof child._store, "React Component in warnForMissingKey should have a _store. " + "This error is likely caused by a bug in React. Please file an issue."), 
+            child._store.validated = !0;
+            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() || "");
+            ownerHasKeyUseWarning[currentComponentErrorInfo] || (ownerHasKeyUseWarning[currentComponentErrorInfo] = !0, 
+            warning$8(!1, "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()));
+        }
+    }, createWorkInProgress$2 = ReactFiber.createWorkInProgress, createFiberFromElement$1 = ReactFiber.createFiberFromElement, createFiberFromFragment$1 = ReactFiber.createFiberFromFragment, createFiberFromText$1 = ReactFiber.createFiberFromText, createFiberFromCoroutine$1 = ReactFiber.createFiberFromCoroutine, createFiberFromYield$1 = ReactFiber.createFiberFromYield, createFiberFromPortal$1 = ReactFiber.createFiberFromPortal, isArray = Array.isArray, FunctionalComponent$2 = ReactTypeOfWork.FunctionalComponent, ClassComponent$7 = ReactTypeOfWork.ClassComponent, HostText$4 = ReactTypeOfWork.HostText, HostPortal$5 = ReactTypeOfWork.HostPortal, CoroutineComponent$2 = ReactTypeOfWork.CoroutineComponent, YieldComponent$3 = ReactTypeOfWork.YieldComponent, Fragment$3 = ReactTypeOfWork.Fragment, NoEffect$2 = ReactTypeOfSideEffect.NoEffect, Placement$3 = ReactTypeOfSideEffect.Placement, Deletion$1 = ReactTypeOfSideEffect.Deletion, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103;
+    function getIteratorFn(maybeIterable) {
+        if (null === maybeIterable || void 0 === maybeIterable) return null;
+        var iteratorFn = ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
+        return "function" == typeof iteratorFn ? iteratorFn : null;
+    }
+    function coerceRef(current, element) {
+        var mixedRef = element.ref;
+        if (null !== mixedRef && "function" != typeof mixedRef) {
+            if (element._owner) {
+                var owner = element._owner, inst = void 0;
+                if (owner) if ("number" == typeof owner.tag) {
+                    var ownerFiber = owner;
+                    invariant(ownerFiber.tag === ClassComponent$7, "Stateless function components cannot have refs."), 
+                    inst = ownerFiber.stateNode;
+                } else inst = owner.getPublicInstance();
+                invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
+                var stringRef = "" + mixedRef;
+                if (null !== current && null !== current.ref && current.ref._stringRef === stringRef) return current.ref;
+                var ref = function(value) {
+                    var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
+                    null === value ? delete refs[stringRef] : refs[stringRef] = value;
+                };
+                return ref._stringRef = stringRef, ref;
+            }
+            invariant("string" == typeof mixedRef, "Expected ref to be a function or a string."), 
+            invariant(element._owner, "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);
+        }
+        return mixedRef;
+    }
+    function throwOnInvalidObjectType(returnFiber, newChild) {
+        if ("textarea" !== returnFiber.type) {
+            var addendum = "";
+            addendum = " If you meant to render a collection of children, use an array " + "instead." + (getCurrentFiberStackAddendum$1() || ""), 
+            invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[object Object]" === Object.prototype.toString.call(newChild) ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild, addendum);
+        }
+    }
+    function warnOnFunctionType() {
+        warning$8(!1, "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() || "");
+    }
+    function ChildReconciler(shouldClone, shouldTrackSideEffects) {
+        function deleteChild(returnFiber, childToDelete) {
+            if (shouldTrackSideEffects) {
+                if (!shouldClone) {
+                    if (null === childToDelete.alternate) return;
+                    childToDelete = childToDelete.alternate;
+                }
+                var last = returnFiber.lastEffect;
+                null !== last ? (last.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete, 
+                childToDelete.nextEffect = null, childToDelete.effectTag = Deletion$1;
+            }
+        }
+        function deleteRemainingChildren(returnFiber, currentFirstChild) {
+            if (!shouldTrackSideEffects) return null;
+            for (var childToDelete = currentFirstChild; null !== childToDelete; ) deleteChild(returnFiber, childToDelete), 
+            childToDelete = childToDelete.sibling;
+            return null;
+        }
+        function mapRemainingChildren(returnFiber, currentFirstChild) {
+            for (var existingChildren = new Map(), existingChild = currentFirstChild; null !== existingChild; ) null !== existingChild.key ? existingChildren.set(existingChild.key, existingChild) : existingChildren.set(existingChild.index, existingChild), 
+            existingChild = existingChild.sibling;
+            return existingChildren;
+        }
+        function useFiber(fiber, priority) {
+            if (shouldClone) {
+                var clone = createWorkInProgress$2(fiber, priority);
+                return clone.index = 0, clone.sibling = null, clone;
+            }
+            return fiber.pendingWorkPriority = priority, fiber.effectTag = NoEffect$2, fiber.index = 0, 
+            fiber.sibling = null, fiber;
+        }
+        function placeChild(newFiber, lastPlacedIndex, newIndex) {
+            if (newFiber.index = newIndex, !shouldTrackSideEffects) return lastPlacedIndex;
+            var current = newFiber.alternate;
+            if (null !== current) {
+                var oldIndex = current.index;
+                return oldIndex < lastPlacedIndex ? (newFiber.effectTag = Placement$3, lastPlacedIndex) : oldIndex;
+            }
+            return newFiber.effectTag = Placement$3, lastPlacedIndex;
+        }
+        function placeSingleChild(newFiber) {
+            return shouldTrackSideEffects && null === newFiber.alternate && (newFiber.effectTag = Placement$3), 
+            newFiber;
+        }
+        function updateTextNode(returnFiber, current, textContent, priority) {
+            if (null === current || current.tag !== HostText$4) {
+                var created = createFiberFromText$1(textContent, returnFiber.internalContextTag, priority);
+                return created.return = returnFiber, created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.pendingProps = textContent, existing.return = returnFiber, existing;
+        }
+        function updateElement(returnFiber, current, element, priority) {
+            if (null === current || current.type !== element.type) {
+                var created = createFiberFromElement$1(element, returnFiber.internalContextTag, priority);
+                return created.ref = coerceRef(current, element), created.return = returnFiber, 
+                created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.ref = coerceRef(current, element), existing.pendingProps = element.props, 
+            existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, 
+            existing;
+        }
+        function updateCoroutine(returnFiber, current, coroutine, priority) {
+            if (null === current || current.tag !== CoroutineComponent$2) {
+                var created = createFiberFromCoroutine$1(coroutine, returnFiber.internalContextTag, priority);
+                return created.return = returnFiber, created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.pendingProps = coroutine, existing.return = returnFiber, existing;
+        }
+        function updateYield(returnFiber, current, yieldNode, priority) {
+            if (null === current || current.tag !== YieldComponent$3) {
+                var created = createFiberFromYield$1(yieldNode, returnFiber.internalContextTag, priority);
+                return created.type = yieldNode.value, created.return = returnFiber, created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.type = yieldNode.value, existing.return = returnFiber, existing;
+        }
+        function updatePortal(returnFiber, current, portal, priority) {
+            if (null === current || current.tag !== HostPortal$5 || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+                var created = createFiberFromPortal$1(portal, returnFiber.internalContextTag, priority);
+                return created.return = returnFiber, created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.pendingProps = portal.children || [], existing.return = returnFiber, 
+            existing;
+        }
+        function updateFragment(returnFiber, current, fragment, priority) {
+            if (null === current || current.tag !== Fragment$3) {
+                var created = createFiberFromFragment$1(fragment, returnFiber.internalContextTag, priority);
+                return created.return = returnFiber, created;
+            }
+            var existing = useFiber(current, priority);
+            return existing.pendingProps = fragment, existing.return = returnFiber, existing;
+        }
+        function createChild(returnFiber, newChild, priority) {
+            if ("string" == typeof newChild || "number" == typeof newChild) {
+                var created = createFiberFromText$1("" + newChild, returnFiber.internalContextTag, priority);
+                return created.return = returnFiber, created;
+            }
+            if ("object" == typeof newChild && null !== newChild) {
+                switch (newChild.$$typeof) {
+                  case REACT_ELEMENT_TYPE:
+                    var _created = createFiberFromElement$1(newChild, returnFiber.internalContextTag, priority);
+                    return _created.ref = coerceRef(null, newChild), _created.return = returnFiber, 
+                    _created;
+
+                  case REACT_COROUTINE_TYPE:
+                    var _created2 = createFiberFromCoroutine$1(newChild, returnFiber.internalContextTag, priority);
+                    return _created2.return = returnFiber, _created2;
+
+                  case REACT_YIELD_TYPE:
+                    var _created3 = createFiberFromYield$1(newChild, returnFiber.internalContextTag, priority);
+                    return _created3.type = newChild.value, _created3.return = returnFiber, _created3;
+
+                  case REACT_PORTAL_TYPE$1:
+                    var _created4 = createFiberFromPortal$1(newChild, returnFiber.internalContextTag, priority);
+                    return _created4.return = returnFiber, _created4;
+                }
+                if (isArray(newChild) || getIteratorFn(newChild)) {
+                    var _created5 = createFiberFromFragment$1(newChild, returnFiber.internalContextTag, priority);
+                    return _created5.return = returnFiber, _created5;
+                }
+                throwOnInvalidObjectType(returnFiber, newChild);
+            }
+            return ReactFeatureFlags_1.disableNewFiberFeatures || "function" != typeof newChild || warnOnFunctionType(), 
+            null;
+        }
+        function updateSlot(returnFiber, oldFiber, newChild, priority) {
+            var key = null !== oldFiber ? oldFiber.key : null;
+            if ("string" == typeof newChild || "number" == typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, priority);
+            if ("object" == typeof newChild && null !== newChild) {
+                switch (newChild.$$typeof) {
+                  case REACT_ELEMENT_TYPE:
+                    return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, priority) : null;
+
+                  case REACT_COROUTINE_TYPE:
+                    return newChild.key === key ? updateCoroutine(returnFiber, oldFiber, newChild, priority) : null;
+
+                  case REACT_YIELD_TYPE:
+                    return null === key ? updateYield(returnFiber, oldFiber, newChild, priority) : null;
+
+                  case REACT_PORTAL_TYPE$1:
+                    return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, priority) : null;
+                }
+                if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, priority);
+                throwOnInvalidObjectType(returnFiber, newChild);
+            }
+            return ReactFeatureFlags_1.disableNewFiberFeatures || "function" != typeof newChild || warnOnFunctionType(), 
+            null;
+        }
+        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, priority) {
+            if ("string" == typeof newChild || "number" == typeof newChild) {
+                return updateTextNode(returnFiber, existingChildren.get(newIdx) || null, "" + newChild, priority);
+            }
+            if ("object" == typeof newChild && null !== newChild) {
+                switch (newChild.$$typeof) {
+                  case REACT_ELEMENT_TYPE:
+                    return updateElement(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
+
+                  case REACT_COROUTINE_TYPE:
+                    return updateCoroutine(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
+
+                  case REACT_YIELD_TYPE:
+                    return updateYield(returnFiber, existingChildren.get(newIdx) || null, newChild, priority);
+
+                  case REACT_PORTAL_TYPE$1:
+                    return updatePortal(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
+                }
+                if (isArray(newChild) || getIteratorFn(newChild)) {
+                    return updateFragment(returnFiber, existingChildren.get(newIdx) || null, newChild, priority);
+                }
+                throwOnInvalidObjectType(returnFiber, newChild);
+            }
+            return ReactFeatureFlags_1.disableNewFiberFeatures || "function" != typeof newChild || warnOnFunctionType(), 
+            null;
+        }
+        function warnOnInvalidKey(child, knownKeys) {
+            if ("object" != typeof child || null === child) return knownKeys;
+            switch (child.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+              case REACT_COROUTINE_TYPE:
+              case REACT_PORTAL_TYPE$1:
+                warnForMissingKey(child);
+                var key = child.key;
+                if ("string" != typeof key) break;
+                if (null === knownKeys) {
+                    knownKeys = new Set(), knownKeys.add(key);
+                    break;
+                }
+                if (!knownKeys.has(key)) {
+                    knownKeys.add(key);
+                    break;
+                }
+                warning$8(!1, "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());
+            }
+            return knownKeys;
+        }
+        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, priority) {
+            for (var knownKeys = null, i = 0; i < newChildren.length; i++) {
+                knownKeys = warnOnInvalidKey(newChildren[i], knownKeys);
+            }
+            for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
+                oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+                var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], priority);
+                if (null === newFiber) {
+                    null === oldFiber && (oldFiber = nextOldFiber);
+                    break;
+                }
+                shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber), 
+                lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber, 
+                previousNewFiber = newFiber, oldFiber = nextOldFiber;
+            }
+            if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), 
+            resultingFirstChild;
+            if (null === oldFiber) {
+                for (;newIdx < newChildren.length; newIdx++) {
+                    var _newFiber = createChild(returnFiber, newChildren[newIdx], priority);
+                    _newFiber && (lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx), 
+                    null === previousNewFiber ? resultingFirstChild = _newFiber : previousNewFiber.sibling = _newFiber, 
+                    previousNewFiber = _newFiber);
+                }
+                return resultingFirstChild;
+            }
+            for (var existingChildren = mapRemainingChildren(returnFiber, oldFiber); newIdx < newChildren.length; newIdx++) {
+                var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], priority);
+                _newFiber2 && (shouldTrackSideEffects && null !== _newFiber2.alternate && existingChildren.delete(null === _newFiber2.key ? newIdx : _newFiber2.key), 
+                lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber2 : previousNewFiber.sibling = _newFiber2, 
+                previousNewFiber = _newFiber2);
+            }
+            return shouldTrackSideEffects && existingChildren.forEach(function(child) {
+                return deleteChild(returnFiber, child);
+            }), resultingFirstChild;
+        }
+        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, priority) {
+            var iteratorFn = getIteratorFn(newChildrenIterable);
+            if (invariant("function" == typeof iteratorFn, "An object is not an iterable. This error is likely caused by a bug in " + "React. Please file an issue."), 
+            "function" == typeof newChildrenIterable.entries) {
+                newChildrenIterable.entries === iteratorFn && (warning$8(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()), 
+                didWarnAboutMaps = !0);
+            }
+            var _newChildren = iteratorFn.call(newChildrenIterable);
+            if (_newChildren) for (var knownKeys = null, _step = _newChildren.next(); !_step.done; _step = _newChildren.next()) {
+                var child = _step.value;
+                knownKeys = warnOnInvalidKey(child, knownKeys);
+            }
+            var newChildren = iteratorFn.call(newChildrenIterable);
+            invariant(null != newChildren, "An iterable object provided no iterator.");
+            for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, 
+            step = newChildren.next()) {
+                oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
+                var newFiber = updateSlot(returnFiber, oldFiber, step.value, priority);
+                if (null === newFiber) {
+                    oldFiber || (oldFiber = nextOldFiber);
+                    break;
+                }
+                shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber), 
+                lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber, 
+                previousNewFiber = newFiber, oldFiber = nextOldFiber;
+            }
+            if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
+            if (null === oldFiber) {
+                for (;!step.done; newIdx++, step = newChildren.next()) {
+                    var _newFiber3 = createChild(returnFiber, step.value, priority);
+                    null !== _newFiber3 && (lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx), 
+                    null === previousNewFiber ? resultingFirstChild = _newFiber3 : previousNewFiber.sibling = _newFiber3, 
+                    previousNewFiber = _newFiber3);
+                }
+                return resultingFirstChild;
+            }
+            for (var existingChildren = mapRemainingChildren(returnFiber, oldFiber); !step.done; newIdx++, 
+            step = newChildren.next()) {
+                var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, priority);
+                null !== _newFiber4 && (shouldTrackSideEffects && null !== _newFiber4.alternate && existingChildren.delete(null === _newFiber4.key ? newIdx : _newFiber4.key), 
+                lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber4 : previousNewFiber.sibling = _newFiber4, 
+                previousNewFiber = _newFiber4);
+            }
+            return shouldTrackSideEffects && existingChildren.forEach(function(child) {
+                return deleteChild(returnFiber, child);
+            }), resultingFirstChild;
+        }
+        function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, priority) {
+            if (null !== currentFirstChild && currentFirstChild.tag === HostText$4) {
+                deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
+                var existing = useFiber(currentFirstChild, priority);
+                return existing.pendingProps = textContent, existing.return = returnFiber, existing;
+            }
+            deleteRemainingChildren(returnFiber, currentFirstChild);
+            var created = createFiberFromText$1(textContent, returnFiber.internalContextTag, priority);
+            return created.return = returnFiber, created;
+        }
+        function reconcileSingleElement(returnFiber, currentFirstChild, element, priority) {
+            for (var key = element.key, child = currentFirstChild; null !== child; ) {
+                if (child.key === key) {
+                    if (child.type === element.type) {
+                        deleteRemainingChildren(returnFiber, child.sibling);
+                        var existing = useFiber(child, priority);
+                        return existing.ref = coerceRef(child, element), existing.pendingProps = element.props, 
+                        existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, 
+                        existing;
+                    }
+                    deleteRemainingChildren(returnFiber, child);
+                    break;
+                }
+                deleteChild(returnFiber, child), child = child.sibling;
+            }
+            var created = createFiberFromElement$1(element, returnFiber.internalContextTag, priority);
+            return created.ref = coerceRef(currentFirstChild, element), created.return = returnFiber, 
+            created;
+        }
+        function reconcileSingleCoroutine(returnFiber, currentFirstChild, coroutine, priority) {
+            for (var key = coroutine.key, child = currentFirstChild; null !== child; ) {
+                if (child.key === key) {
+                    if (child.tag === CoroutineComponent$2) {
+                        deleteRemainingChildren(returnFiber, child.sibling);
+                        var existing = useFiber(child, priority);
+                        return existing.pendingProps = coroutine, existing.return = returnFiber, existing;
+                    }
+                    deleteRemainingChildren(returnFiber, child);
+                    break;
+                }
+                deleteChild(returnFiber, child), child = child.sibling;
+            }
+            var created = createFiberFromCoroutine$1(coroutine, returnFiber.internalContextTag, priority);
+            return created.return = returnFiber, created;
+        }
+        function reconcileSingleYield(returnFiber, currentFirstChild, yieldNode, priority) {
+            var child = currentFirstChild;
+            if (null !== child) {
+                if (child.tag === YieldComponent$3) {
+                    deleteRemainingChildren(returnFiber, child.sibling);
+                    var existing = useFiber(child, priority);
+                    return existing.type = yieldNode.value, existing.return = returnFiber, existing;
+                }
+                deleteRemainingChildren(returnFiber, child);
+            }
+            var created = createFiberFromYield$1(yieldNode, returnFiber.internalContextTag, priority);
+            return created.type = yieldNode.value, created.return = returnFiber, created;
+        }
+        function reconcileSinglePortal(returnFiber, currentFirstChild, portal, priority) {
+            for (var key = portal.key, child = currentFirstChild; null !== child; ) {
+                if (child.key === key) {
+                    if (child.tag === HostPortal$5 && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+                        deleteRemainingChildren(returnFiber, child.sibling);
+                        var existing = useFiber(child, priority);
+                        return existing.pendingProps = portal.children || [], existing.return = returnFiber, 
+                        existing;
+                    }
+                    deleteRemainingChildren(returnFiber, child);
+                    break;
+                }
+                deleteChild(returnFiber, child), child = child.sibling;
+            }
+            var created = createFiberFromPortal$1(portal, returnFiber.internalContextTag, priority);
+            return created.return = returnFiber, created;
+        }
+        function reconcileChildFibers(returnFiber, currentFirstChild, newChild, priority) {
+            var disableNewFiberFeatures = ReactFeatureFlags_1.disableNewFiberFeatures, isObject = "object" == typeof newChild && null !== newChild;
+            if (isObject) if (disableNewFiberFeatures) switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, priority));
+
+              case REACT_PORTAL_TYPE$1:
+                return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, priority));
+            } else switch (newChild.$$typeof) {
+              case REACT_ELEMENT_TYPE:
+                return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, priority));
+
+              case REACT_COROUTINE_TYPE:
+                return placeSingleChild(reconcileSingleCoroutine(returnFiber, currentFirstChild, newChild, priority));
+
+              case REACT_YIELD_TYPE:
+                return placeSingleChild(reconcileSingleYield(returnFiber, currentFirstChild, newChild, priority));
+
+              case REACT_PORTAL_TYPE$1:
+                return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, priority));
+            }
+            if (disableNewFiberFeatures) switch (returnFiber.tag) {
+              case ClassComponent$7:
+                if (returnFiber.stateNode.render._isMockFunction && void 0 === newChild) break;
+                var Component = returnFiber.type;
+                invariant(null === newChild || !1 === newChild, "%s.render(): A valid React element (or null) must be returned. " + "You may have returned undefined, an array or some other " + "invalid object.", Component.displayName || Component.name || "Component");
+                break;
+
+              case FunctionalComponent$2:
+                var _Component = returnFiber.type;
+                invariant(null === newChild || !1 === newChild, "%s(...): A valid React element (or null) must be returned. " + "You may have returned undefined, an array or some other " + "invalid object.", _Component.displayName || _Component.name || "Component");
+            }
+            if ("string" == typeof newChild || "number" == typeof newChild) return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, "" + newChild, priority));
+            if (isArray(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, priority);
+            if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, priority);
+            if (isObject && throwOnInvalidObjectType(returnFiber, newChild), disableNewFiberFeatures || "function" != typeof newChild || warnOnFunctionType(), 
+            !disableNewFiberFeatures && void 0 === newChild) switch (returnFiber.tag) {
+              case ClassComponent$7:
+                if (returnFiber.stateNode.render._isMockFunction) break;
+
+              case FunctionalComponent$2:
+                var _Component2 = returnFiber.type;
+                invariant(!1, "%s(...): Nothing was returned from render. This usually means a " + "return statement is missing. Or, to render nothing, " + "return null.", _Component2.displayName || _Component2.name || "Component");
+            }
+            return deleteRemainingChildren(returnFiber, currentFirstChild);
+        }
+        return reconcileChildFibers;
+    }
+    var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlace$1 = ChildReconciler(!1, !0), mountChildFibersInPlace$1 = ChildReconciler(!1, !1), cloneChildFibers$1 = function(current, workInProgress) {
+        if (invariant(null === current || workInProgress.child === current.child, "Resuming work not yet implemented."), 
+        null !== workInProgress.child) {
+            var currentChild = workInProgress.child, newChild = createWorkInProgress$2(currentChild, currentChild.pendingWorkPriority);
+            for (newChild.pendingProps = currentChild.pendingProps, workInProgress.child = newChild, 
+            newChild.return = workInProgress; null !== currentChild.sibling; ) currentChild = currentChild.sibling, 
+            newChild = newChild.sibling = createWorkInProgress$2(currentChild, currentChild.pendingWorkPriority), 
+            newChild.pendingProps = currentChild.pendingProps, newChild.return = workInProgress;
+            newChild.sibling = null;
+        }
+    }, ReactChildFiber = {
+        reconcileChildFibers: reconcileChildFibers$1,
+        reconcileChildFibersInPlace: reconcileChildFibersInPlace$1,
+        mountChildFibersInPlace: mountChildFibersInPlace$1,
+        cloneChildFibers: cloneChildFibers$1
+    }, Update$1 = ReactTypeOfSideEffect.Update, AsyncUpdates$1 = ReactTypeOfInternalContext.AsyncUpdates, cacheContext$1 = ReactFiberContext.cacheContext, getMaskedContext$2 = ReactFiberContext.getMaskedContext, getUnmaskedContext$2 = ReactFiberContext.getUnmaskedContext, isContextConsumer$1 = ReactFiberContext.isContextConsumer, addUpdate$1 = ReactFiberUpdateQueue.addUpdate, addReplaceUpdate$1 = ReactFiberUpdateQueue.addReplaceUpdate, addForceUpdate$1 = ReactFiberUpdateQueue.addForceUpdate, beginUpdateQueue$2 = ReactFiberUpdateQueue.beginUpdateQueue, _require5 = ReactFiberContext, hasContextChanged$2 = _require5.hasContextChanged, isMounted$1 = ReactFiberTreeReflection.isMounted, isArray$1 = Array.isArray, _require7$1 = ReactDebugFiberPerf_1, startPhaseTimer$1 = _require7$1.startPhaseTimer, stopPhaseTimer$1 = _require7$1.stopPhaseTimer, warning$9 = require$$0, warnOnInvalidCallback = function(callback, callerName) {
+        warning$9(null === callback || "function" == typeof callback, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
+    }, ReactFiberClassComponent = function(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState) {
+        var updater = {
+            isMounted: isMounted$1,
+            enqueueSetState: function(instance, partialState, callback) {
+                var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
+                callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "setState"), 
+                addUpdate$1(fiber, partialState, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
+            },
+            enqueueReplaceState: function(instance, state, callback) {
+                var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
+                callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "replaceState"), 
+                addReplaceUpdate$1(fiber, state, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
+            },
+            enqueueForceUpdate: function(instance, callback) {
+                var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
+                callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "forceUpdate"), 
+                addForceUpdate$1(fiber, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
+            }
+        };
+        function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
+            if (null === oldProps || null !== workInProgress.updateQueue && workInProgress.updateQueue.hasForceUpdate) return !0;
+            var instance = workInProgress.stateNode, type = workInProgress.type;
+            if ("function" == typeof instance.shouldComponentUpdate) {
+                startPhaseTimer$1(workInProgress, "shouldComponentUpdate");
+                var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext);
+                return stopPhaseTimer$1(), warning$9(void 0 !== shouldUpdate, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName_1(workInProgress) || "Unknown"), 
+                shouldUpdate;
+            }
+            return !type.prototype || !type.prototype.isPureReactComponent || (!shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState));
+        }
+        function checkClassInstance(workInProgress) {
+            var instance = workInProgress.stateNode, type = workInProgress.type, name = getComponentName_1(workInProgress), renderPresent = instance.render;
+            warning$9(renderPresent, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
+            var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
+            warning$9(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);
+            var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
+            warning$9(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);
+            var noInstancePropTypes = !instance.propTypes;
+            warning$9(noInstancePropTypes, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name);
+            var noInstanceContextTypes = !instance.contextTypes;
+            warning$9(noInstanceContextTypes, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name);
+            var noComponentShouldUpdate = "function" != typeof instance.componentShouldUpdate;
+            warning$9(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), 
+            type.prototype && type.prototype.isPureReactComponent && void 0 !== instance.shouldComponentUpdate && warning$9(!1, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName_1(workInProgress) || "A pure component");
+            var noComponentDidUnmount = "function" != typeof instance.componentDidUnmount;
+            warning$9(noComponentDidUnmount, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name);
+            var noComponentWillRecieveProps = "function" != typeof instance.componentWillRecieveProps;
+            warning$9(noComponentWillRecieveProps, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name);
+            var hasMutatedProps = instance.props !== workInProgress.pendingProps;
+            warning$9(void 0 === instance.props || !hasMutatedProps, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name);
+            var noInstanceDefaultProps = !instance.defaultProps;
+            warning$9(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);
+            var state = instance.state;
+            state && ("object" != typeof state || isArray$1(state)) && invariant(!1, "%s.state: must be set to an object or null", getComponentName_1(workInProgress)), 
+            "function" == typeof instance.getChildContext && invariant("object" == typeof workInProgress.type.childContextTypes, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", getComponentName_1(workInProgress));
+        }
+        function resetInputPointers(workInProgress, instance) {
+            instance.props = workInProgress.memoizedProps, instance.state = workInProgress.memoizedState;
+        }
+        function adoptClassInstance(workInProgress, instance) {
+            instance.updater = updater, workInProgress.stateNode = instance, ReactInstanceMap_1.set(instance, workInProgress);
+        }
+        function constructClassInstance(workInProgress, props) {
+            var ctor = workInProgress.type, unmaskedContext = getUnmaskedContext$2(workInProgress), needsContext = isContextConsumer$1(workInProgress), context = needsContext ? getMaskedContext$2(workInProgress, unmaskedContext) : emptyObject, instance = new ctor(props, context);
+            return adoptClassInstance(workInProgress, instance), needsContext && cacheContext$1(workInProgress, unmaskedContext, context), 
+            instance;
+        }
+        function callComponentWillMount(workInProgress, instance) {
+            startPhaseTimer$1(workInProgress, "componentWillMount");
+            var oldState = instance.state;
+            instance.componentWillMount(), stopPhaseTimer$1(), oldState !== instance.state && (warning$9(!1, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName_1(workInProgress)), 
+            updater.enqueueReplaceState(instance, instance.state, null));
+        }
+        function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
+            startPhaseTimer$1(workInProgress, "componentWillReceiveProps");
+            var oldState = instance.state;
+            instance.componentWillReceiveProps(newProps, newContext), stopPhaseTimer$1(), instance.state !== oldState && (warning$9(!1, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName_1(workInProgress)), 
+            updater.enqueueReplaceState(instance, instance.state, null));
+        }
+        function mountClassInstance(workInProgress, priorityLevel) {
+            var current = workInProgress.alternate;
+            checkClassInstance(workInProgress);
+            var instance = workInProgress.stateNode, state = instance.state || null, props = workInProgress.pendingProps;
+            invariant(props, "There must be pending props for an initial mount. This error is " + "likely caused by a bug in React. Please file an issue.");
+            var unmaskedContext = getUnmaskedContext$2(workInProgress);
+            if (instance.props = props, instance.state = state, instance.refs = emptyObject, 
+            instance.context = getMaskedContext$2(workInProgress, unmaskedContext), ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != workInProgress.type && null != workInProgress.type.prototype && !0 === workInProgress.type.prototype.unstable_isAsyncReactComponent && (workInProgress.internalContextTag |= AsyncUpdates$1), 
+            "function" == typeof instance.componentWillMount) {
+                callComponentWillMount(workInProgress, instance);
+                var updateQueue = workInProgress.updateQueue;
+                null !== updateQueue && (instance.state = beginUpdateQueue$2(current, workInProgress, updateQueue, instance, state, props, priorityLevel));
+            }
+            "function" == typeof instance.componentDidMount && (workInProgress.effectTag |= Update$1);
+        }
+        function updateClassInstance(current, workInProgress, priorityLevel) {
+            var instance = workInProgress.stateNode;
+            resetInputPointers(workInProgress, instance);
+            var oldProps = workInProgress.memoizedProps, newProps = workInProgress.pendingProps;
+            newProps || (newProps = oldProps, invariant(null != newProps, "There should always be pending or memoized props. This error is " + "likely caused by a bug in React. Please file an issue."));
+            var oldContext = instance.context, newUnmaskedContext = getUnmaskedContext$2(workInProgress), newContext = getMaskedContext$2(workInProgress, newUnmaskedContext);
+            "function" != typeof instance.componentWillReceiveProps || oldProps === newProps && oldContext === newContext || callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
+            var oldState = workInProgress.memoizedState, newState = void 0;
+            if (newState = null !== workInProgress.updateQueue ? beginUpdateQueue$2(current, workInProgress, workInProgress.updateQueue, instance, oldState, newProps, priorityLevel) : oldState, 
+            !(oldProps !== newProps || oldState !== newState || hasContextChanged$2() || null !== workInProgress.updateQueue && workInProgress.updateQueue.hasForceUpdate)) return "function" == typeof instance.componentDidUpdate && (oldProps === current.memoizedProps && oldState === current.memoizedState || (workInProgress.effectTag |= Update$1)), 
+            !1;
+            var shouldUpdate = checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);
+            return shouldUpdate ? ("function" == typeof instance.componentWillUpdate && (startPhaseTimer$1(workInProgress, "componentWillUpdate"), 
+            instance.componentWillUpdate(newProps, newState, newContext), stopPhaseTimer$1()), 
+            "function" == typeof instance.componentDidUpdate && (workInProgress.effectTag |= Update$1)) : ("function" == typeof instance.componentDidUpdate && (oldProps === current.memoizedProps && oldState === current.memoizedState || (workInProgress.effectTag |= Update$1)), 
+            memoizeProps(workInProgress, newProps), memoizeState(workInProgress, newState)), 
+            instance.props = newProps, instance.state = newState, instance.context = newContext, 
+            shouldUpdate;
+        }
+        return {
+            adoptClassInstance: adoptClassInstance,
+            constructClassInstance: constructClassInstance,
+            mountClassInstance: mountClassInstance,
+            updateClassInstance: updateClassInstance
+        };
+    }, mountChildFibersInPlace = ReactChildFiber.mountChildFibersInPlace, reconcileChildFibers = ReactChildFiber.reconcileChildFibers, reconcileChildFibersInPlace = ReactChildFiber.reconcileChildFibersInPlace, cloneChildFibers = ReactChildFiber.cloneChildFibers, beginUpdateQueue$1 = ReactFiberUpdateQueue.beginUpdateQueue, getMaskedContext$1 = ReactFiberContext.getMaskedContext, getUnmaskedContext$1 = ReactFiberContext.getUnmaskedContext, hasContextChanged$1 = ReactFiberContext.hasContextChanged, pushContextProvider$1 = ReactFiberContext.pushContextProvider, pushTopLevelContextObject$1 = ReactFiberContext.pushTopLevelContextObject, invalidateContextProvider$1 = ReactFiberContext.invalidateContextProvider, IndeterminateComponent$2 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$1 = ReactTypeOfWork.FunctionalComponent, ClassComponent$6 = ReactTypeOfWork.ClassComponent, HostRoot$6 = ReactTypeOfWork.HostRoot, HostComponent$6 = ReactTypeOfWork.HostComponent, HostText$3 = ReactTypeOfWork.HostText, HostPortal$4 = ReactTypeOfWork.HostPortal, CoroutineComponent$1 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$2 = ReactTypeOfWork.YieldComponent, Fragment$2 = ReactTypeOfWork.Fragment, NoWork$3 = ReactPriorityLevel.NoWork, OffscreenPriority$1 = ReactPriorityLevel.OffscreenPriority, PerformedWork$1 = ReactTypeOfSideEffect.PerformedWork, Placement$2 = ReactTypeOfSideEffect.Placement, ContentReset$1 = ReactTypeOfSideEffect.ContentReset, Err$1 = ReactTypeOfSideEffect.Err, Ref$1 = ReactTypeOfSideEffect.Ref, ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, ReactDebugCurrentFiber$4 = ReactDebugCurrentFiber_1, _require7 = ReactDebugFiberPerf_1, cancelWorkTimer = _require7.cancelWorkTimer, warning$7 = require$$0, warnedAboutStatelessRefs = {}, ReactFiberBeginWork = function(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext) {
+        var shouldSetTextContent = config.shouldSetTextContent, useSyncScheduling = config.useSyncScheduling, shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree, pushHostContext = hostContext.pushHostContext, pushHostContainer = hostContext.pushHostContainer, enterHydrationState = hydrationContext.enterHydrationState, resetHydrationState = hydrationContext.resetHydrationState, tryToClaimNextHydratableInstance = hydrationContext.tryToClaimNextHydratableInstance, _ReactFiberClassCompo = ReactFiberClassComponent(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState), adoptClassInstance = _ReactFiberClassCompo.adoptClassInstance, constructClassInstance = _ReactFiberClassCompo.constructClassInstance, mountClassInstance = _ReactFiberClassCompo.mountClassInstance, updateClassInstance = _ReactFiberClassCompo.updateClassInstance;
+        function reconcileChildren(current, workInProgress, nextChildren) {
+            reconcileChildrenAtPriority(current, workInProgress, nextChildren, workInProgress.pendingWorkPriority);
+        }
+        function reconcileChildrenAtPriority(current, workInProgress, nextChildren, priorityLevel) {
+            null === current ? workInProgress.child = mountChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel) : current.child === workInProgress.child ? workInProgress.child = reconcileChildFibers(workInProgress, workInProgress.child, nextChildren, priorityLevel) : workInProgress.child = reconcileChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel);
+        }
+        function updateFragment(current, workInProgress) {
+            var nextChildren = workInProgress.pendingProps;
+            if (hasContextChanged$1()) null === nextChildren && (nextChildren = workInProgress.memoizedProps); else if (null === nextChildren || workInProgress.memoizedProps === nextChildren) return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            return reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextChildren), 
+            workInProgress.child;
+        }
+        function markRef(current, workInProgress) {
+            var ref = workInProgress.ref;
+            null === ref || current && current.ref === ref || (workInProgress.effectTag |= Ref$1);
+        }
+        function updateFunctionalComponent(current, workInProgress) {
+            var fn = workInProgress.type, nextProps = workInProgress.pendingProps, memoizedProps = workInProgress.memoizedProps;
+            if (hasContextChanged$1()) null === nextProps && (nextProps = memoizedProps); else if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            var nextChildren, unmaskedContext = getUnmaskedContext$1(workInProgress), context = getMaskedContext$1(workInProgress, unmaskedContext);
+            return ReactCurrentOwner$2.current = workInProgress, ReactDebugCurrentFiber$4.setCurrentFiber(workInProgress, "render"), 
+            nextChildren = fn(nextProps, context), ReactDebugCurrentFiber$4.setCurrentFiber(workInProgress, null), 
+            workInProgress.effectTag |= PerformedWork$1, reconcileChildren(current, workInProgress, nextChildren), 
+            memoizeProps(workInProgress, nextProps), workInProgress.child;
+        }
+        function updateClassComponent(current, workInProgress, priorityLevel) {
+            var hasContext = pushContextProvider$1(workInProgress), shouldUpdate = void 0;
+            return null === current ? workInProgress.stateNode ? invariant(!1, "Resuming work not yet implemented.") : (constructClassInstance(workInProgress, workInProgress.pendingProps), 
+            mountClassInstance(workInProgress, priorityLevel), shouldUpdate = !0) : shouldUpdate = updateClassInstance(current, workInProgress, priorityLevel), 
+            finishClassComponent(current, workInProgress, shouldUpdate, hasContext);
+        }
+        function finishClassComponent(current, workInProgress, shouldUpdate, hasContext) {
+            if (markRef(current, workInProgress), !shouldUpdate) return hasContext && invalidateContextProvider$1(workInProgress, !1), 
+            bailoutOnAlreadyFinishedWork(current, workInProgress);
+            var instance = workInProgress.stateNode;
+            ReactCurrentOwner$2.current = workInProgress;
+            var nextChildren = void 0;
+            return ReactDebugCurrentFiber$4.setCurrentFiber(workInProgress, "render"), nextChildren = instance.render(), 
+            ReactDebugCurrentFiber$4.setCurrentFiber(workInProgress, null), workInProgress.effectTag |= PerformedWork$1, 
+            reconcileChildren(current, workInProgress, nextChildren), memoizeState(workInProgress, instance.state), 
+            memoizeProps(workInProgress, instance.props), hasContext && invalidateContextProvider$1(workInProgress, !0), 
+            workInProgress.child;
+        }
+        function updateHostRoot(current, workInProgress, priorityLevel) {
+            var root = workInProgress.stateNode;
+            root.pendingContext ? pushTopLevelContextObject$1(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject$1(workInProgress, root.context, !1), 
+            pushHostContainer(workInProgress, root.containerInfo);
+            var updateQueue = workInProgress.updateQueue;
+            if (null !== updateQueue) {
+                var prevState = workInProgress.memoizedState, state = beginUpdateQueue$1(current, workInProgress, updateQueue, null, prevState, null, priorityLevel);
+                if (prevState === state) return resetHydrationState(), bailoutOnAlreadyFinishedWork(current, workInProgress);
+                var element = state.element;
+                return null !== current && null !== current.child || !enterHydrationState(workInProgress) ? (resetHydrationState(), 
+                reconcileChildren(current, workInProgress, element)) : (workInProgress.effectTag |= Placement$2, 
+                workInProgress.child = mountChildFibersInPlace(workInProgress, workInProgress.child, element, priorityLevel)), 
+                memoizeState(workInProgress, state), workInProgress.child;
+            }
+            return resetHydrationState(), bailoutOnAlreadyFinishedWork(current, workInProgress);
+        }
+        function updateHostComponent(current, workInProgress, renderPriority) {
+            pushHostContext(workInProgress), null === current && tryToClaimNextHydratableInstance(workInProgress);
+            var type = workInProgress.type, memoizedProps = workInProgress.memoizedProps, nextProps = workInProgress.pendingProps;
+            null === nextProps && (nextProps = memoizedProps, invariant(null !== nextProps, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue."));
+            var prevProps = null !== current ? current.memoizedProps : null;
+            if (hasContextChanged$1()) ; else if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            var nextChildren = nextProps.children;
+            return shouldSetTextContent(type, nextProps) ? nextChildren = null : prevProps && shouldSetTextContent(type, prevProps) && (workInProgress.effectTag |= ContentReset$1), 
+            markRef(current, workInProgress), renderPriority !== OffscreenPriority$1 && !useSyncScheduling && shouldDeprioritizeSubtree(type, nextProps) ? (workInProgress.pendingWorkPriority = OffscreenPriority$1, 
+            null) : (reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextProps), 
+            workInProgress.child);
+        }
+        function updateHostText(current, workInProgress) {
+            null === current && tryToClaimNextHydratableInstance(workInProgress);
+            var nextProps = workInProgress.pendingProps;
+            return null === nextProps && (nextProps = workInProgress.memoizedProps), memoizeProps(workInProgress, nextProps), 
+            null;
+        }
+        function mountIndeterminateComponent(current, workInProgress, priorityLevel) {
+            invariant(null === current, "An indeterminate component should never have mounted. This error is " + "likely caused by a bug in React. Please file an issue.");
+            var value, fn = workInProgress.type, props = workInProgress.pendingProps, unmaskedContext = getUnmaskedContext$1(workInProgress), context = getMaskedContext$1(workInProgress, unmaskedContext);
+            if (ReactCurrentOwner$2.current = workInProgress, value = fn(props, context), workInProgress.effectTag |= PerformedWork$1, 
+            "object" == typeof value && null !== value && "function" == typeof value.render) {
+                workInProgress.tag = ClassComponent$6;
+                var hasContext = pushContextProvider$1(workInProgress);
+                return adoptClassInstance(workInProgress, value), mountClassInstance(workInProgress, priorityLevel), 
+                finishClassComponent(current, workInProgress, !0, hasContext);
+            }
+            workInProgress.tag = FunctionalComponent$1;
+            var Component = workInProgress.type;
+            if (Component && warning$7(!Component.childContextTypes, "%s(...): childContextTypes cannot be defined on a functional component.", Component.displayName || Component.name || "Component"), 
+            null !== workInProgress.ref) {
+                var info = "", ownerName = ReactDebugCurrentFiber$4.getCurrentFiberOwnerName();
+                ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`.");
+                var warningKey = ownerName || workInProgress._debugID || "", debugSource = workInProgress._debugSource;
+                debugSource && (warningKey = debugSource.fileName + ":" + debugSource.lineNumber), 
+                warnedAboutStatelessRefs[warningKey] || (warnedAboutStatelessRefs[warningKey] = !0, 
+                warning$7(!1, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactDebugCurrentFiber$4.getCurrentFiberStackAddendum()));
+            }
+            return reconcileChildren(current, workInProgress, value), memoizeProps(workInProgress, props), 
+            workInProgress.child;
+        }
+        function updateCoroutineComponent(current, workInProgress) {
+            var nextCoroutine = workInProgress.pendingProps;
+            hasContextChanged$1() ? null === nextCoroutine && (nextCoroutine = current && current.memoizedProps, 
+            invariant(null !== nextCoroutine, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue.")) : null !== nextCoroutine && workInProgress.memoizedProps !== nextCoroutine || (nextCoroutine = workInProgress.memoizedProps);
+            var nextChildren = nextCoroutine.children, priorityLevel = workInProgress.pendingWorkPriority;
+            return null === current ? workInProgress.stateNode = mountChildFibersInPlace(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel) : current.child === workInProgress.child ? workInProgress.stateNode = reconcileChildFibers(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel) : workInProgress.stateNode = reconcileChildFibersInPlace(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel), 
+            memoizeProps(workInProgress, nextCoroutine), workInProgress.stateNode;
+        }
+        function updatePortalComponent(current, workInProgress) {
+            pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+            var priorityLevel = workInProgress.pendingWorkPriority, nextChildren = workInProgress.pendingProps;
+            if (hasContextChanged$1()) null === nextChildren && (nextChildren = current && current.memoizedProps, 
+            invariant(null != nextChildren, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue.")); else if (null === nextChildren || workInProgress.memoizedProps === nextChildren) return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            return null === current ? (workInProgress.child = reconcileChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel), 
+            memoizeProps(workInProgress, nextChildren)) : (reconcileChildren(current, workInProgress, nextChildren), 
+            memoizeProps(workInProgress, nextChildren)), workInProgress.child;
+        }
+        function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+            return cancelWorkTimer(workInProgress), cloneChildFibers(current, workInProgress), 
+            workInProgress.child;
+        }
+        function bailoutOnLowPriority(current, workInProgress) {
+            switch (cancelWorkTimer(workInProgress), workInProgress.tag) {
+              case ClassComponent$6:
+                pushContextProvider$1(workInProgress);
+                break;
+
+              case HostPortal$4:
+                pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
+            }
+            return null;
+        }
+        function memoizeProps(workInProgress, nextProps) {
+            workInProgress.memoizedProps = nextProps;
+        }
+        function memoizeState(workInProgress, nextState) {
+            workInProgress.memoizedState = nextState;
+        }
+        function beginWork(current, workInProgress, priorityLevel) {
+            if (workInProgress.pendingWorkPriority === NoWork$3 || workInProgress.pendingWorkPriority > priorityLevel) return bailoutOnLowPriority(current, workInProgress);
+            switch (ReactDebugCurrentFiber$4.setCurrentFiber(workInProgress, null), workInProgress.tag) {
+              case IndeterminateComponent$2:
+                return mountIndeterminateComponent(current, workInProgress, priorityLevel);
+
+              case FunctionalComponent$1:
+                return updateFunctionalComponent(current, workInProgress);
+
+              case ClassComponent$6:
+                return updateClassComponent(current, workInProgress, priorityLevel);
+
+              case HostRoot$6:
+                return updateHostRoot(current, workInProgress, priorityLevel);
+
+              case HostComponent$6:
+                return updateHostComponent(current, workInProgress, priorityLevel);
+
+              case HostText$3:
+                return updateHostText(current, workInProgress);
+
+              case CoroutineHandlerPhase:
+                workInProgress.tag = CoroutineComponent$1;
+
+              case CoroutineComponent$1:
+                return updateCoroutineComponent(current, workInProgress);
+
+              case YieldComponent$2:
+                return null;
+
+              case HostPortal$4:
+                return updatePortalComponent(current, workInProgress);
+
+              case Fragment$2:
+                return updateFragment(current, workInProgress);
+
+              default:
+                invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+            }
+        }
+        function beginFailedWork(current, workInProgress, priorityLevel) {
+            switch (workInProgress.tag) {
+              case ClassComponent$6:
+                pushContextProvider$1(workInProgress);
+                break;
+
+              case HostRoot$6:
+                var root = workInProgress.stateNode;
+                pushHostContainer(workInProgress, root.containerInfo);
+                break;
+
+              default:
+                invariant(!1, "Invalid type of work. This error is likely caused by a bug in React. " + "Please file an issue.");
+            }
+            if (workInProgress.effectTag |= Err$1, null === current ? workInProgress.child = null : workInProgress.child !== current.child && (workInProgress.child = current.child), 
+            workInProgress.pendingWorkPriority === NoWork$3 || workInProgress.pendingWorkPriority > priorityLevel) return bailoutOnLowPriority(current, workInProgress);
+            if (workInProgress.firstEffect = null, workInProgress.lastEffect = null, reconcileChildrenAtPriority(current, workInProgress, null, priorityLevel), 
+            workInProgress.tag === ClassComponent$6) {
+                var instance = workInProgress.stateNode;
+                workInProgress.memoizedProps = instance.props, workInProgress.memoizedState = instance.state;
+            }
+            return workInProgress.child;
+        }
+        return {
+            beginWork: beginWork,
+            beginFailedWork: beginFailedWork
+        };
+    }, reconcileChildFibers$2 = ReactChildFiber.reconcileChildFibers, popContextProvider$2 = ReactFiberContext.popContextProvider, IndeterminateComponent$3 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$3 = ReactTypeOfWork.FunctionalComponent, ClassComponent$8 = ReactTypeOfWork.ClassComponent, HostRoot$7 = ReactTypeOfWork.HostRoot, HostComponent$7 = ReactTypeOfWork.HostComponent, HostText$5 = ReactTypeOfWork.HostText, HostPortal$6 = ReactTypeOfWork.HostPortal, CoroutineComponent$3 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase$1 = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$4 = ReactTypeOfWork.YieldComponent, Fragment$4 = ReactTypeOfWork.Fragment, Placement$4 = ReactTypeOfSideEffect.Placement, Ref$2 = ReactTypeOfSideEffect.Ref, Update$2 = ReactTypeOfSideEffect.Update, OffscreenPriority$2 = ReactPriorityLevel.OffscreenPriority, ReactDebugCurrentFiber$5 = ReactDebugCurrentFiber_1, ReactFiberCompleteWork = function(config, hostContext, hydrationContext) {
+        var createInstance = config.createInstance, createTextInstance = config.createTextInstance, appendInitialChild = config.appendInitialChild, finalizeInitialChildren = config.finalizeInitialChildren, prepareUpdate = config.prepareUpdate, getRootHostContainer = hostContext.getRootHostContainer, popHostContext = hostContext.popHostContext, getHostContext = hostContext.getHostContext, popHostContainer = hostContext.popHostContainer, prepareToHydrateHostInstance = hydrationContext.prepareToHydrateHostInstance, prepareToHydrateHostTextInstance = hydrationContext.prepareToHydrateHostTextInstance, popHydrationState = hydrationContext.popHydrationState;
+        function markUpdate(workInProgress) {
+            workInProgress.effectTag |= Update$2;
+        }
+        function markRef(workInProgress) {
+            workInProgress.effectTag |= Ref$2;
+        }
+        function appendAllYields(yields, workInProgress) {
+            var node = workInProgress.stateNode;
+            for (node && (node.return = workInProgress); null !== node; ) {
+                if (node.tag === HostComponent$7 || node.tag === HostText$5 || node.tag === HostPortal$6) invariant(!1, "A coroutine cannot have host component children."); else if (node.tag === YieldComponent$4) yields.push(node.type); else if (null !== node.child) {
+                    node.child.return = node, node = node.child;
+                    continue;
+                }
+                for (;null === node.sibling; ) {
+                    if (null === node.return || node.return === workInProgress) return;
+                    node = node.return;
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            }
+        }
+        function moveCoroutineToHandlerPhase(current, workInProgress) {
+            var coroutine = workInProgress.memoizedProps;
+            invariant(coroutine, "Should be resolved by now. This error is likely caused by a bug in " + "React. Please file an issue."), 
+            workInProgress.tag = CoroutineHandlerPhase$1;
+            var yields = [];
+            appendAllYields(yields, workInProgress);
+            var fn = coroutine.handler, props = coroutine.props, nextChildren = fn(props, yields), currentFirstChild = null !== current ? current.child : null, priority = workInProgress.pendingWorkPriority;
+            return workInProgress.child = reconcileChildFibers$2(workInProgress, currentFirstChild, nextChildren, priority), 
+            workInProgress.child;
+        }
+        function appendAllChildren(parent, workInProgress) {
+            for (var node = workInProgress.child; null !== node; ) {
+                if (node.tag === HostComponent$7 || node.tag === HostText$5) appendInitialChild(parent, node.stateNode); else if (node.tag === HostPortal$6) ; else if (null !== node.child) {
+                    node = node.child;
+                    continue;
+                }
+                if (node === workInProgress) return;
+                for (;null === node.sibling; ) {
+                    if (null === node.return || node.return === workInProgress) return;
+                    node = node.return;
+                }
+                node = node.sibling;
+            }
+        }
+        function completeWork(current, workInProgress, renderPriority) {
+            ReactDebugCurrentFiber$5.setCurrentFiber(workInProgress, null);
+            var newProps = workInProgress.pendingProps;
+            switch (null === newProps ? newProps = workInProgress.memoizedProps : workInProgress.pendingWorkPriority === OffscreenPriority$2 && renderPriority !== OffscreenPriority$2 || (workInProgress.pendingProps = null), 
+            workInProgress.tag) {
+              case FunctionalComponent$3:
+                return null;
+
+              case ClassComponent$8:
+                return popContextProvider$2(workInProgress), null;
+
+              case HostRoot$7:
+                var fiberRoot = workInProgress.stateNode;
+                return fiberRoot.pendingContext && (fiberRoot.context = fiberRoot.pendingContext, 
+                fiberRoot.pendingContext = null), null !== current && null !== current.child || (popHydrationState(workInProgress), 
+                workInProgress.effectTag &= ~Placement$4), null;
+
+              case HostComponent$7:
+                popHostContext(workInProgress);
+                var rootContainerInstance = getRootHostContainer(), type = workInProgress.type;
+                if (null !== current && null != workInProgress.stateNode) {
+                    var oldProps = current.memoizedProps, instance = workInProgress.stateNode, currentHostContext = getHostContext(), updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
+                    workInProgress.updateQueue = updatePayload, updatePayload && markUpdate(workInProgress), 
+                    current.ref !== workInProgress.ref && markRef(workInProgress);
+                } else {
+                    if (!newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue."), 
+                    null;
+                    var _currentHostContext = getHostContext();
+                    if (popHydrationState(workInProgress)) prepareToHydrateHostInstance(workInProgress, rootContainerInstance) && markUpdate(workInProgress); else {
+                        var _instance = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress);
+                        appendAllChildren(_instance, workInProgress), finalizeInitialChildren(_instance, type, newProps, rootContainerInstance) && markUpdate(workInProgress), 
+                        workInProgress.stateNode = _instance;
+                    }
+                    null !== workInProgress.ref && markRef(workInProgress);
+                }
+                return null;
+
+              case HostText$5:
+                var newText = newProps;
+                if (current && null != workInProgress.stateNode) {
+                    current.memoizedProps !== newText && markUpdate(workInProgress);
+                } else {
+                    if ("string" != typeof newText) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue."), 
+                    null;
+                    var _rootContainerInstance = getRootHostContainer(), _currentHostContext2 = getHostContext();
+                    popHydrationState(workInProgress) ? prepareToHydrateHostTextInstance(workInProgress) && markUpdate(workInProgress) : workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress);
+                }
+                return null;
+
+              case CoroutineComponent$3:
+                return moveCoroutineToHandlerPhase(current, workInProgress);
+
+              case CoroutineHandlerPhase$1:
+                return workInProgress.tag = CoroutineComponent$3, null;
+
+              case YieldComponent$4:
+              case Fragment$4:
+                return null;
+
+              case HostPortal$6:
+                return markUpdate(workInProgress), popHostContainer(workInProgress), null;
+
+              case IndeterminateComponent$3:
+                invariant(!1, "An indeterminate component should have become determinate before " + "completing. This error is likely caused by a bug in React. Please " + "file an issue.");
+
+              default:
+                invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
+            }
+        }
+        return {
+            completeWork: completeWork
+        };
+    }, warning$10 = require$$0, onCommitFiberRoot = null, onCommitFiberUnmount = null, hasLoggedError = !1;
+    function catchErrors(fn) {
+        return function(arg) {
+            try {
+                return fn(arg);
+            } catch (err) {
+                0 || hasLoggedError || (hasLoggedError = !0, warning$10(!1, "React DevTools encountered an error: %s", err));
+            }
+        };
+    }
+    function injectInternals$1(internals) {
+        if ("undefined" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+        var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+        if (!hook.supportsFiber) return warning$10(!1, "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"), 
+        !0;
+        try {
+            var rendererID = hook.inject(internals);
+            onCommitFiberRoot = catchErrors(function(root) {
+                return hook.onCommitFiberRoot(rendererID, root);
+            }), onCommitFiberUnmount = catchErrors(function(fiber) {
+                return hook.onCommitFiberUnmount(rendererID, fiber);
+            });
+        } catch (err) {
+            warning$10(!1, "React DevTools encountered an error: %s.", err);
         }
         return !0;
     }
-    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
-    !0);
-}
-
-function publishRegistrationName(registrationName, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
-    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
-    var lowerCasedName = registrationName.toLowerCase();
-    EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName, 
-    "onDoubleClick" === registrationName && (EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName);
-}
-
-var EventPluginRegistry = {
-    plugins: [],
-    eventNameDispatchConfigs: {},
-    registrationNameModules: {},
-    registrationNameDependencies: {},
-    possibleRegistrationNames: {},
-    injectEventPluginOrder: function(injectedEventPluginOrder) {
-        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
-        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
-    },
-    injectEventPluginsByName: function(injectedNamesToPlugins) {
-        var isOrderingDirty = !1;
-        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
-            var pluginModule = injectedNamesToPlugins[pluginName];
-            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
-            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
-        }
-        isOrderingDirty && recomputePluginOrdering();
+    function onCommitRoot$1(root) {
+        "function" == typeof onCommitFiberRoot && onCommitFiberRoot(root);
     }
-}, EventPluginRegistry_1 = EventPluginRegistry;
-
-function accumulateInto(current, next) {
-    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
-    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulateInto_1 = accumulateInto;
-
-function forEachAccumulated(arr, cb, scope) {
-    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
-}
-
-var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
-    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
-}, executeDispatchesAndReleaseSimulated = function(e) {
-    return executeDispatchesAndRelease(e, !0);
-}, executeDispatchesAndReleaseTopLevel = function(e) {
-    return executeDispatchesAndRelease(e, !1);
-};
-
-function isInteractive(tag) {
-    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-    switch (name) {
-      case "onClick":
-      case "onClickCapture":
-      case "onDoubleClick":
-      case "onDoubleClickCapture":
-      case "onMouseDown":
-      case "onMouseDownCapture":
-      case "onMouseMove":
-      case "onMouseMoveCapture":
-      case "onMouseUp":
-      case "onMouseUpCapture":
-        return !(!props.disabled || !isInteractive(type));
-
-      default:
-        return !1;
+    function onCommitUnmount$1(fiber) {
+        "function" == typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
     }
-}
-
-var EventPluginHub = {
-    injection: {
-        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
-        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
-    },
-    getListener: function(inst, registrationName) {
-        var listener;
-        if ("number" == typeof inst.tag) {
-            var stateNode = inst.stateNode;
-            if (!stateNode) return null;
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
-            if (!props) return null;
-            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
-        } else {
-            var currentElement = inst._currentElement;
-            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
-            if (!inst._rootNodeID) return null;
-            var _props = currentElement.props;
-            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
-        }
-        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
-        listener;
-    },
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
-            var possiblePlugin = plugins[i];
-            if (possiblePlugin) {
-                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+    var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCommitUnmount_1 = onCommitUnmount$1, ReactFiberDevToolsHook = {
+        injectInternals: injectInternals_1,
+        onCommitRoot: onCommitRoot_1,
+        onCommitUnmount: onCommitUnmount_1
+    }, ClassComponent$9 = ReactTypeOfWork.ClassComponent, HostRoot$8 = ReactTypeOfWork.HostRoot, HostComponent$8 = ReactTypeOfWork.HostComponent, HostText$6 = ReactTypeOfWork.HostText, HostPortal$7 = ReactTypeOfWork.HostPortal, CoroutineComponent$4 = ReactTypeOfWork.CoroutineComponent, commitCallbacks$1 = ReactFiberUpdateQueue.commitCallbacks, onCommitUnmount = ReactFiberDevToolsHook.onCommitUnmount, invokeGuardedCallback$2 = ReactErrorUtils_1.invokeGuardedCallback, hasCaughtError$1 = ReactErrorUtils_1.hasCaughtError, clearCaughtError$1 = ReactErrorUtils_1.clearCaughtError, Placement$5 = ReactTypeOfSideEffect.Placement, Update$3 = ReactTypeOfSideEffect.Update, Callback$1 = ReactTypeOfSideEffect.Callback, ContentReset$2 = ReactTypeOfSideEffect.ContentReset, _require5$1 = ReactDebugFiberPerf_1, startPhaseTimer$2 = _require5$1.startPhaseTimer, stopPhaseTimer$2 = _require5$1.stopPhaseTimer, ReactFiberCommitWork = function(config, captureError) {
+        var commitMount = config.commitMount, commitUpdate = config.commitUpdate, resetTextContent = config.resetTextContent, commitTextUpdate = config.commitTextUpdate, appendChild = config.appendChild, appendChildToContainer = config.appendChildToContainer, insertBefore = config.insertBefore, insertInContainerBefore = config.insertInContainerBefore, removeChild = config.removeChild, removeChildFromContainer = config.removeChildFromContainer, getPublicInstance = config.getPublicInstance, callComponentWillUnmountWithTimerInDev = function(current, instance) {
+            startPhaseTimer$2(current, "componentWillUnmount"), instance.componentWillUnmount(), 
+            stopPhaseTimer$2();
+        };
+        function safelyCallComponentWillUnmount(current, instance) {
+            if (invokeGuardedCallback$2(null, callComponentWillUnmountWithTimerInDev, null, current, instance), 
+            hasCaughtError$1()) {
+                var unmountError = clearCaughtError$1();
+                captureError(current, unmountError);
             }
         }
-        return events;
-    },
-    enqueueEvents: function(events) {
-        events && (eventQueue = accumulateInto_1(eventQueue, events));
-    },
-    processEventQueue: function(simulated) {
-        var processingEventQueue = eventQueue;
-        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
-        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
-        ReactErrorUtils_1.rethrowCaughtError();
+        function safelyDetachRef(current) {
+            var ref = current.ref;
+            if (null !== ref && (invokeGuardedCallback$2(null, ref, null, null), hasCaughtError$1())) {
+                var refError = clearCaughtError$1();
+                captureError(current, refError);
+            }
+        }
+        function getHostParentFiber(fiber) {
+            for (var parent = fiber.return; null !== parent; ) {
+                if (isHostParent(parent)) return parent;
+                parent = parent.return;
+            }
+            invariant(!1, "Expected to find a host parent. This error is likely caused by a bug " + "in React. Please file an issue.");
+        }
+        function isHostParent(fiber) {
+            return fiber.tag === HostComponent$8 || fiber.tag === HostRoot$8 || fiber.tag === HostPortal$7;
+        }
+        function getHostSibling(fiber) {
+            var node = fiber;
+            siblings: for (;!0; ) {
+                for (;null === node.sibling; ) {
+                    if (null === node.return || isHostParent(node.return)) return null;
+                    node = node.return;
+                }
+                for (node.sibling.return = node.return, node = node.sibling; node.tag !== HostComponent$8 && node.tag !== HostText$6; ) {
+                    if (node.effectTag & Placement$5) continue siblings;
+                    if (null === node.child || node.tag === HostPortal$7) continue siblings;
+                    node.child.return = node, node = node.child;
+                }
+                if (!(node.effectTag & Placement$5)) return node.stateNode;
+            }
+        }
+        function commitPlacement(finishedWork) {
+            var parentFiber = getHostParentFiber(finishedWork), parent = void 0, isContainer = void 0;
+            switch (parentFiber.tag) {
+              case HostComponent$8:
+                parent = parentFiber.stateNode, isContainer = !1;
+                break;
+
+              case HostRoot$8:
+              case HostPortal$7:
+                parent = parentFiber.stateNode.containerInfo, isContainer = !0;
+                break;
+
+              default:
+                invariant(!1, "Invalid host parent fiber. This error is likely caused by a bug " + "in React. Please file an issue.");
+            }
+            parentFiber.effectTag & ContentReset$2 && (resetTextContent(parent), parentFiber.effectTag &= ~ContentReset$2);
+            for (var before = getHostSibling(finishedWork), node = finishedWork; !0; ) {
+                if (node.tag === HostComponent$8 || node.tag === HostText$6) before ? isContainer ? insertInContainerBefore(parent, node.stateNode, before) : insertBefore(parent, node.stateNode, before) : isContainer ? appendChildToContainer(parent, node.stateNode) : appendChild(parent, node.stateNode); else if (node.tag === HostPortal$7) ; else if (null !== node.child) {
+                    node.child.return = node, node = node.child;
+                    continue;
+                }
+                if (node === finishedWork) return;
+                for (;null === node.sibling; ) {
+                    if (null === node.return || node.return === finishedWork) return;
+                    node = node.return;
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            }
+        }
+        function commitNestedUnmounts(root) {
+            for (var node = root; !0; ) if (commitUnmount(node), null === node.child || node.tag === HostPortal$7) {
+                if (node === root) return;
+                for (;null === node.sibling; ) {
+                    if (null === node.return || node.return === root) return;
+                    node = node.return;
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            } else node.child.return = node, node = node.child;
+        }
+        function unmountHostComponents(current) {
+            for (var node = current, currentParentIsValid = !1, currentParent = void 0, currentParentIsContainer = void 0; !0; ) {
+                if (!currentParentIsValid) {
+                    var parent = node.return;
+                    findParent: for (;!0; ) {
+                        switch (invariant(null !== parent, "Expected to find a host parent. This error is likely caused by " + "a bug in React. Please file an issue."), 
+                        parent.tag) {
+                          case HostComponent$8:
+                            currentParent = parent.stateNode, currentParentIsContainer = !1;
+                            break findParent;
+
+                          case HostRoot$8:
+                          case HostPortal$7:
+                            currentParent = parent.stateNode.containerInfo, currentParentIsContainer = !0;
+                            break findParent;
+                        }
+                        parent = parent.return;
+                    }
+                    currentParentIsValid = !0;
+                }
+                if (node.tag === HostComponent$8 || node.tag === HostText$6) commitNestedUnmounts(node), 
+                currentParentIsContainer ? removeChildFromContainer(currentParent, node.stateNode) : removeChild(currentParent, node.stateNode); else if (node.tag === HostPortal$7) {
+                    if (currentParent = node.stateNode.containerInfo, null !== node.child) {
+                        node.child.return = node, node = node.child;
+                        continue;
+                    }
+                } else if (commitUnmount(node), null !== node.child) {
+                    node.child.return = node, node = node.child;
+                    continue;
+                }
+                if (node === current) return;
+                for (;null === node.sibling; ) {
+                    if (null === node.return || node.return === current) return;
+                    node = node.return, node.tag === HostPortal$7 && (currentParentIsValid = !1);
+                }
+                node.sibling.return = node.return, node = node.sibling;
+            }
+        }
+        function commitDeletion(current) {
+            unmountHostComponents(current), current.return = null, current.child = null, current.alternate && (current.alternate.child = null, 
+            current.alternate.return = null);
+        }
+        function commitUnmount(current) {
+            switch ("function" == typeof onCommitUnmount && onCommitUnmount(current), current.tag) {
+              case ClassComponent$9:
+                safelyDetachRef(current);
+                var instance = current.stateNode;
+                return void ("function" == typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(current, instance));
+
+              case HostComponent$8:
+                return void safelyDetachRef(current);
+
+              case CoroutineComponent$4:
+                return void commitNestedUnmounts(current.stateNode);
+
+              case HostPortal$7:
+                return void unmountHostComponents(current);
+            }
+        }
+        function commitWork(current, finishedWork) {
+            switch (finishedWork.tag) {
+              case ClassComponent$9:
+                return;
+
+              case HostComponent$8:
+                var instance = finishedWork.stateNode;
+                if (null != instance) {
+                    var newProps = finishedWork.memoizedProps, oldProps = null !== current ? current.memoizedProps : newProps, type = finishedWork.type, updatePayload = finishedWork.updateQueue;
+                    finishedWork.updateQueue = null, null !== updatePayload && commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
+                }
+                return;
+
+              case HostText$6:
+                invariant(null !== finishedWork.stateNode, "This should have a text node initialized. This error is likely " + "caused by a bug in React. Please file an issue.");
+                var textInstance = finishedWork.stateNode, newText = finishedWork.memoizedProps, oldText = null !== current ? current.memoizedProps : newText;
+                return void commitTextUpdate(textInstance, oldText, newText);
+
+              case HostRoot$8:
+              case HostPortal$7:
+                return;
+
+              default:
+                invariant(!1, "This unit of work tag should not have side-effects. This error is " + "likely caused by a bug in React. Please file an issue.");
+            }
+        }
+        function commitLifeCycles(current, finishedWork) {
+            switch (finishedWork.tag) {
+              case ClassComponent$9:
+                var instance = finishedWork.stateNode;
+                if (finishedWork.effectTag & Update$3) if (null === current) startPhaseTimer$2(finishedWork, "componentDidMount"), 
+                instance.componentDidMount(), stopPhaseTimer$2(); else {
+                    var prevProps = current.memoizedProps, prevState = current.memoizedState;
+                    startPhaseTimer$2(finishedWork, "componentDidUpdate"), instance.componentDidUpdate(prevProps, prevState), 
+                    stopPhaseTimer$2();
+                }
+                return void (finishedWork.effectTag & Callback$1 && null !== finishedWork.updateQueue && commitCallbacks$1(finishedWork, finishedWork.updateQueue, instance));
+
+              case HostRoot$8:
+                var updateQueue = finishedWork.updateQueue;
+                if (null !== updateQueue) {
+                    var _instance = finishedWork.child && finishedWork.child.stateNode;
+                    commitCallbacks$1(finishedWork, updateQueue, _instance);
+                }
+                return;
+
+              case HostComponent$8:
+                var _instance2 = finishedWork.stateNode;
+                if (null === current && finishedWork.effectTag & Update$3) {
+                    var type = finishedWork.type, props = finishedWork.memoizedProps;
+                    commitMount(_instance2, type, props, finishedWork);
+                }
+                return;
+
+              case HostText$6:
+              case HostPortal$7:
+                return;
+
+              default:
+                invariant(!1, "This unit of work tag should not have side-effects. This error is " + "likely caused by a bug in React. Please file an issue.");
+            }
+        }
+        function commitAttachRef(finishedWork) {
+            var ref = finishedWork.ref;
+            if (null !== ref) {
+                var instance = finishedWork.stateNode;
+                switch (finishedWork.tag) {
+                  case HostComponent$8:
+                    ref(getPublicInstance(instance));
+                    break;
+
+                  default:
+                    ref(instance);
+                }
+            }
+        }
+        function commitDetachRef(current) {
+            var currentRef = current.ref;
+            null !== currentRef && currentRef(null);
+        }
+        return {
+            commitPlacement: commitPlacement,
+            commitDeletion: commitDeletion,
+            commitWork: commitWork,
+            commitLifeCycles: commitLifeCycles,
+            commitAttachRef: commitAttachRef,
+            commitDetachRef: commitDetachRef
+        };
+    }, createCursor$2 = ReactFiberStack.createCursor, pop$2 = ReactFiberStack.pop, push$2 = ReactFiberStack.push, NO_CONTEXT = {}, ReactFiberHostContext = function(config) {
+        var getChildHostContext = config.getChildHostContext, getRootHostContext = config.getRootHostContext, contextStackCursor = createCursor$2(NO_CONTEXT), contextFiberStackCursor = createCursor$2(NO_CONTEXT), rootInstanceStackCursor = createCursor$2(NO_CONTEXT);
+        function requiredContext(c) {
+            return invariant(c !== NO_CONTEXT, "Expected host context to exist. This error is likely caused by a bug " + "in React. Please file an issue."), 
+            c;
+        }
+        function getRootHostContainer() {
+            return requiredContext(rootInstanceStackCursor.current);
+        }
+        function pushHostContainer(fiber, nextRootInstance) {
+            push$2(rootInstanceStackCursor, nextRootInstance, fiber);
+            var nextRootContext = getRootHostContext(nextRootInstance);
+            push$2(contextFiberStackCursor, fiber, fiber), push$2(contextStackCursor, nextRootContext, fiber);
+        }
+        function popHostContainer(fiber) {
+            pop$2(contextStackCursor, fiber), pop$2(contextFiberStackCursor, fiber), pop$2(rootInstanceStackCursor, fiber);
+        }
+        function getHostContext() {
+            return requiredContext(contextStackCursor.current);
+        }
+        function pushHostContext(fiber) {
+            var rootInstance = requiredContext(rootInstanceStackCursor.current), context = requiredContext(contextStackCursor.current), nextContext = getChildHostContext(context, fiber.type, rootInstance);
+            context !== nextContext && (push$2(contextFiberStackCursor, fiber, fiber), push$2(contextStackCursor, nextContext, fiber));
+        }
+        function popHostContext(fiber) {
+            contextFiberStackCursor.current === fiber && (pop$2(contextStackCursor, fiber), 
+            pop$2(contextFiberStackCursor, fiber));
+        }
+        function resetHostContainer() {
+            contextStackCursor.current = NO_CONTEXT, rootInstanceStackCursor.current = NO_CONTEXT;
+        }
+        return {
+            getHostContext: getHostContext,
+            getRootHostContainer: getRootHostContainer,
+            popHostContainer: popHostContainer,
+            popHostContext: popHostContext,
+            pushHostContainer: pushHostContainer,
+            pushHostContext: pushHostContext,
+            resetHostContainer: resetHostContainer
+        };
+    }, HostComponent$9 = ReactTypeOfWork.HostComponent, HostText$7 = ReactTypeOfWork.HostText, HostRoot$9 = ReactTypeOfWork.HostRoot, Deletion$2 = ReactTypeOfSideEffect.Deletion, Placement$6 = ReactTypeOfSideEffect.Placement, createFiberFromHostInstanceForDeletion$1 = ReactFiber.createFiberFromHostInstanceForDeletion, ReactFiberHydrationContext = function(config) {
+        var shouldSetTextContent = config.shouldSetTextContent, canHydrateInstance = config.canHydrateInstance, canHydrateTextInstance = config.canHydrateTextInstance, getNextHydratableSibling = config.getNextHydratableSibling, getFirstHydratableChild = config.getFirstHydratableChild, hydrateInstance = config.hydrateInstance, hydrateTextInstance = config.hydrateTextInstance, didNotHydrateInstance = config.didNotHydrateInstance, didNotFindHydratableInstance = config.didNotFindHydratableInstance, didNotFindHydratableTextInstance = config.didNotFindHydratableTextInstance;
+        if (!(canHydrateInstance && canHydrateTextInstance && getNextHydratableSibling && getFirstHydratableChild && hydrateInstance && hydrateTextInstance && didNotHydrateInstance && didNotFindHydratableInstance && didNotFindHydratableTextInstance)) return {
+            enterHydrationState: function() {
+                return !1;
+            },
+            resetHydrationState: function() {},
+            tryToClaimNextHydratableInstance: function() {},
+            prepareToHydrateHostInstance: function() {
+                invariant(!1, "Expected prepareToHydrateHostInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+            },
+            prepareToHydrateHostTextInstance: function() {
+                invariant(!1, "Expected prepareToHydrateHostTextInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
+            },
+            popHydrationState: function(fiber) {
+                return !1;
+            }
+        };
+        var hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
+        function enterHydrationState(fiber) {
+            var parentInstance = fiber.stateNode.containerInfo;
+            return nextHydratableInstance = getFirstHydratableChild(parentInstance), hydrationParentFiber = fiber, 
+            isHydrating = !0, !0;
+        }
+        function deleteHydratableInstance(returnFiber, instance) {
+            switch (returnFiber.tag) {
+              case HostRoot$9:
+                didNotHydrateInstance(returnFiber.stateNode.containerInfo, instance);
+                break;
+
+              case HostComponent$9:
+                didNotHydrateInstance(returnFiber.stateNode, instance);
+            }
+            var childToDelete = createFiberFromHostInstanceForDeletion$1();
+            childToDelete.stateNode = instance, childToDelete.return = returnFiber, childToDelete.effectTag = Deletion$2, 
+            null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = childToDelete, 
+            returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
+        }
+        function insertNonHydratedInstance(returnFiber, fiber) {
+            fiber.effectTag |= Placement$6;
+            var parentInstance;
+            switch (returnFiber.tag) {
+              case HostComponent$9:
+                parentInstance = returnFiber.stateNode;
+                break;
+
+              default:
+                return;
+            }
+            switch (fiber.tag) {
+              case HostComponent$9:
+                var type = fiber.type, props = fiber.pendingProps;
+                didNotFindHydratableInstance(parentInstance, type, props);
+                break;
+
+              case HostText$7:
+                var text = fiber.pendingProps;
+                didNotFindHydratableTextInstance(parentInstance, text);
+            }
+        }
+        function canHydrate(fiber, nextInstance) {
+            switch (fiber.tag) {
+              case HostComponent$9:
+                var type = fiber.type, props = fiber.pendingProps;
+                return canHydrateInstance(nextInstance, type, props);
+
+              case HostText$7:
+                var text = fiber.pendingProps;
+                return canHydrateTextInstance(nextInstance, text);
+
+              default:
+                return !1;
+            }
+        }
+        function tryToClaimNextHydratableInstance(fiber) {
+            if (isHydrating) {
+                var nextInstance = nextHydratableInstance;
+                if (!nextInstance) return insertNonHydratedInstance(hydrationParentFiber, fiber), 
+                isHydrating = !1, void (hydrationParentFiber = fiber);
+                if (!canHydrate(fiber, nextInstance)) {
+                    if (!(nextInstance = getNextHydratableSibling(nextInstance)) || !canHydrate(fiber, nextInstance)) return insertNonHydratedInstance(hydrationParentFiber, fiber), 
+                    isHydrating = !1, void (hydrationParentFiber = fiber);
+                    deleteHydratableInstance(hydrationParentFiber, nextHydratableInstance);
+                }
+                fiber.stateNode = nextInstance, hydrationParentFiber = fiber, nextHydratableInstance = getFirstHydratableChild(nextInstance);
+            }
+        }
+        function prepareToHydrateHostInstance(fiber, rootContainerInstance) {
+            var instance = fiber.stateNode, updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, fiber);
+            return fiber.updateQueue = updatePayload, null !== updatePayload;
+        }
+        function prepareToHydrateHostTextInstance(fiber) {
+            var textInstance = fiber.stateNode;
+            return hydrateTextInstance(textInstance, fiber.memoizedProps, fiber);
+        }
+        function popToNextHostParent(fiber) {
+            for (var parent = fiber.return; null !== parent && parent.tag !== HostComponent$9 && parent.tag !== HostRoot$9; ) parent = parent.return;
+            hydrationParentFiber = parent;
+        }
+        function popHydrationState(fiber) {
+            if (fiber !== hydrationParentFiber) return !1;
+            if (!isHydrating) return popToNextHostParent(fiber), isHydrating = !0, !1;
+            var type = fiber.type;
+            if (fiber.tag !== HostComponent$9 || "head" !== type && "body" !== type && !shouldSetTextContent(type, fiber.memoizedProps)) for (var nextInstance = nextHydratableInstance; nextInstance; ) deleteHydratableInstance(fiber, nextInstance), 
+            nextInstance = getNextHydratableSibling(nextInstance);
+            return popToNextHostParent(fiber), nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null, 
+            !0;
+        }
+        function resetHydrationState() {
+            hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
+        }
+        return {
+            enterHydrationState: enterHydrationState,
+            resetHydrationState: resetHydrationState,
+            tryToClaimNextHydratableInstance: tryToClaimNextHydratableInstance,
+            prepareToHydrateHostInstance: prepareToHydrateHostInstance,
+            prepareToHydrateHostTextInstance: prepareToHydrateHostTextInstance,
+            popHydrationState: popHydrationState
+        };
+    }, ReactFiberInstrumentation$2 = {
+        debugTool: null
+    }, ReactFiberInstrumentation_1 = ReactFiberInstrumentation$2, popContextProvider$1 = ReactFiberContext.popContextProvider, reset$1 = ReactFiberStack.reset, getStackAddendumByWorkInProgressFiber$2 = ReactFiberComponentTreeHook.getStackAddendumByWorkInProgressFiber, logCapturedError$1 = ReactFiberErrorLogger.logCapturedError, invokeGuardedCallback$1 = ReactErrorUtils_1.invokeGuardedCallback, hasCaughtError = ReactErrorUtils_1.hasCaughtError, clearCaughtError = ReactErrorUtils_1.clearCaughtError, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, createWorkInProgress$1 = ReactFiber.createWorkInProgress, largerPriority$1 = ReactFiber.largerPriority, onCommitRoot = ReactFiberDevToolsHook.onCommitRoot, NoWork$2 = ReactPriorityLevel.NoWork, SynchronousPriority$1 = ReactPriorityLevel.SynchronousPriority, TaskPriority$1 = ReactPriorityLevel.TaskPriority, HighPriority = ReactPriorityLevel.HighPriority, LowPriority = ReactPriorityLevel.LowPriority, OffscreenPriority = ReactPriorityLevel.OffscreenPriority, AsyncUpdates = ReactTypeOfInternalContext.AsyncUpdates, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement$1 = ReactTypeOfSideEffect.Placement, Update = ReactTypeOfSideEffect.Update, PlacementAndUpdate = ReactTypeOfSideEffect.PlacementAndUpdate, Deletion = ReactTypeOfSideEffect.Deletion, ContentReset = ReactTypeOfSideEffect.ContentReset, Callback = ReactTypeOfSideEffect.Callback, Err = ReactTypeOfSideEffect.Err, Ref = ReactTypeOfSideEffect.Ref, HostRoot$5 = ReactTypeOfWork.HostRoot, HostComponent$5 = ReactTypeOfWork.HostComponent, HostPortal$3 = ReactTypeOfWork.HostPortal, ClassComponent$5 = ReactTypeOfWork.ClassComponent, getUpdatePriority$1 = ReactFiberUpdateQueue.getUpdatePriority, _require14 = ReactFiberContext, resetContext$1 = _require14.resetContext, warning$6 = require$$0, ReactFiberInstrumentation$1 = ReactFiberInstrumentation_1, ReactDebugCurrentFiber$3 = ReactDebugCurrentFiber_1, _require15 = ReactDebugFiberPerf_1, recordEffect = _require15.recordEffect, recordScheduleUpdate = _require15.recordScheduleUpdate, startWorkTimer = _require15.startWorkTimer, stopWorkTimer = _require15.stopWorkTimer, stopFailedWorkTimer = _require15.stopFailedWorkTimer, startWorkLoopTimer = _require15.startWorkLoopTimer, stopWorkLoopTimer = _require15.stopWorkLoopTimer, startCommitTimer = _require15.startCommitTimer, stopCommitTimer = _require15.stopCommitTimer, startCommitHostEffectsTimer = _require15.startCommitHostEffectsTimer, stopCommitHostEffectsTimer = _require15.stopCommitHostEffectsTimer, startCommitLifeCyclesTimer = _require15.startCommitLifeCyclesTimer, stopCommitLifeCyclesTimer = _require15.stopCommitLifeCyclesTimer, warnAboutUpdateOnUnmounted = function(instance) {
+        var ctor = instance.constructor;
+        warning$6(!1, "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.", ctor && (ctor.displayName || ctor.name) || "ReactClass");
+    }, warnAboutInvalidUpdates = function(instance) {
+        switch (ReactDebugCurrentFiber$3.phase) {
+          case "getChildContext":
+            warning$6(!1, "setState(...): Cannot call setState() inside getChildContext()");
+            break;
+
+          case "render":
+            warning$6(!1, "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`.");
+        }
+    }, timeHeuristicForUnitOfWork = 1, ReactFiberScheduler = function(config) {
+        var hostContext = ReactFiberHostContext(config), hydrationContext = ReactFiberHydrationContext(config), popHostContainer = hostContext.popHostContainer, popHostContext = hostContext.popHostContext, resetHostContainer = hostContext.resetHostContainer, _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext), beginWork = _ReactFiberBeginWork.beginWork, beginFailedWork = _ReactFiberBeginWork.beginFailedWork, _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, hydrationContext), completeWork = _ReactFiberCompleteWo.completeWork, _ReactFiberCommitWork = ReactFiberCommitWork(config, captureError), commitPlacement = _ReactFiberCommitWork.commitPlacement, commitDeletion = _ReactFiberCommitWork.commitDeletion, commitWork = _ReactFiberCommitWork.commitWork, commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles, commitAttachRef = _ReactFiberCommitWork.commitAttachRef, commitDetachRef = _ReactFiberCommitWork.commitDetachRef, scheduleDeferredCallback = config.scheduleDeferredCallback, useSyncScheduling = config.useSyncScheduling, prepareForCommit = config.prepareForCommit, resetAfterCommit = config.resetAfterCommit, priorityContext = NoWork$2, isPerformingWork = !1, deadlineHasExpired = !1, isBatchingUpdates = !1, isUnbatchingUpdates = !1, nextUnitOfWork = null, nextPriorityLevel = NoWork$2, nextEffect = null, pendingCommit = null, nextScheduledRoot = null, lastScheduledRoot = null, isCallbackScheduled = !1, capturedErrors = null, failedBoundaries = null, commitPhaseBoundaries = null, firstUncaughtError = null, didFatal = !1, isCommitting = !1, isUnmounting = !1, NESTED_UPDATE_LIMIT = 1e3, nestedUpdateCount = 0;
+        function resetContextStack() {
+            reset$1(), resetContext$1(), resetHostContainer();
+        }
+        function resetNextUnitOfWork() {
+            for (;null !== nextScheduledRoot && nextScheduledRoot.current.pendingWorkPriority === NoWork$2; ) {
+                nextScheduledRoot.isScheduled = !1;
+                var next = nextScheduledRoot.nextScheduledRoot;
+                if (nextScheduledRoot.nextScheduledRoot = null, nextScheduledRoot === lastScheduledRoot) return nextScheduledRoot = null, 
+                lastScheduledRoot = null, nextPriorityLevel = NoWork$2, null;
+                nextScheduledRoot = next;
+            }
+            for (var root = nextScheduledRoot, highestPriorityRoot = null, highestPriorityLevel = NoWork$2; null !== root; ) root.current.pendingWorkPriority !== NoWork$2 && (highestPriorityLevel === NoWork$2 || highestPriorityLevel > root.current.pendingWorkPriority) && (highestPriorityLevel = root.current.pendingWorkPriority, 
+            highestPriorityRoot = root), root = root.nextScheduledRoot;
+            if (null !== highestPriorityRoot) return nextPriorityLevel = highestPriorityLevel, 
+            resetContextStack(), void (nextUnitOfWork = createWorkInProgress$1(highestPriorityRoot.current, highestPriorityLevel));
+            nextPriorityLevel = NoWork$2, nextUnitOfWork = null;
+        }
+        function commitAllHostEffects() {
+            for (;null !== nextEffect; ) {
+                ReactDebugCurrentFiber$3.setCurrentFiber(nextEffect, null), recordEffect();
+                var effectTag = nextEffect.effectTag;
+                if (effectTag & ContentReset && config.resetTextContent(nextEffect.stateNode), effectTag & Ref) {
+                    var current = nextEffect.alternate;
+                    null !== current && commitDetachRef(current);
+                }
+                switch (effectTag & ~(Callback | Err | ContentReset | Ref | PerformedWork)) {
+                  case Placement$1:
+                    commitPlacement(nextEffect), nextEffect.effectTag &= ~Placement$1;
+                    break;
+
+                  case PlacementAndUpdate:
+                    commitPlacement(nextEffect), nextEffect.effectTag &= ~Placement$1;
+                    var _current = nextEffect.alternate;
+                    commitWork(_current, nextEffect);
+                    break;
+
+                  case Update:
+                    var _current2 = nextEffect.alternate;
+                    commitWork(_current2, nextEffect);
+                    break;
+
+                  case Deletion:
+                    isUnmounting = !0, commitDeletion(nextEffect), isUnmounting = !1;
+                }
+                nextEffect = nextEffect.nextEffect;
+            }
+            ReactDebugCurrentFiber$3.resetCurrentFiber();
+        }
+        function commitAllLifeCycles() {
+            for (;null !== nextEffect; ) {
+                var effectTag = nextEffect.effectTag;
+                if (effectTag & (Update | Callback)) {
+                    recordEffect();
+                    var current = nextEffect.alternate;
+                    commitLifeCycles(current, nextEffect);
+                }
+                effectTag & Ref && (recordEffect(), commitAttachRef(nextEffect)), effectTag & Err && (recordEffect(), 
+                commitErrorHandling(nextEffect));
+                var next = nextEffect.nextEffect;
+                nextEffect.nextEffect = null, nextEffect = next;
+            }
+        }
+        function commitAllWork(finishedWork) {
+            isCommitting = !0, startCommitTimer(), pendingCommit = null;
+            var root = finishedWork.stateNode;
+            invariant(root.current !== finishedWork, "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."), 
+            nextPriorityLevel !== SynchronousPriority$1 && nextPriorityLevel !== TaskPriority$1 || nestedUpdateCount++, 
+            ReactCurrentOwner$1.current = null;
+            var firstEffect = void 0;
+            for (finishedWork.effectTag > PerformedWork ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, 
+            firstEffect = finishedWork.firstEffect) : firstEffect = finishedWork : firstEffect = finishedWork.firstEffect, 
+            prepareForCommit(), nextEffect = firstEffect, startCommitHostEffectsTimer(); null !== nextEffect; ) {
+                var didError = !1, _error = void 0;
+                invokeGuardedCallback$1(null, commitAllHostEffects, null), hasCaughtError() && (didError = !0, 
+                _error = clearCaughtError()), didError && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
+                captureError(nextEffect, _error), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
+            }
+            for (stopCommitHostEffectsTimer(), resetAfterCommit(), root.current = finishedWork, 
+            nextEffect = firstEffect, startCommitLifeCyclesTimer(); null !== nextEffect; ) {
+                var _didError = !1, _error2 = void 0;
+                invokeGuardedCallback$1(null, commitAllLifeCycles, null), hasCaughtError() && (_didError = !0, 
+                _error2 = clearCaughtError()), _didError && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
+                captureError(nextEffect, _error2), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
+            }
+            isCommitting = !1, stopCommitLifeCyclesTimer(), stopCommitTimer(), "function" == typeof onCommitRoot && onCommitRoot(finishedWork.stateNode), 
+            !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCommitWork(finishedWork), 
+            commitPhaseBoundaries && (commitPhaseBoundaries.forEach(scheduleErrorRecovery), 
+            commitPhaseBoundaries = null), resetNextUnitOfWork();
+        }
+        function resetWorkPriority(workInProgress, renderPriority) {
+            if (!(workInProgress.pendingWorkPriority !== NoWork$2 && workInProgress.pendingWorkPriority > renderPriority)) {
+                for (var newPriority = getUpdatePriority$1(workInProgress), child = workInProgress.child; null !== child; ) newPriority = largerPriority$1(newPriority, child.pendingWorkPriority), 
+                child = child.sibling;
+                workInProgress.pendingWorkPriority = newPriority;
+            }
+        }
+        function completeUnitOfWork(workInProgress) {
+            for (;!0; ) {
+                var current = workInProgress.alternate, next = completeWork(current, workInProgress, nextPriorityLevel), returnFiber = workInProgress.return, siblingFiber = workInProgress.sibling;
+                if (resetWorkPriority(workInProgress, nextPriorityLevel), null !== next) return stopWorkTimer(workInProgress), 
+                !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCompleteWork(workInProgress), 
+                next;
+                if (null !== returnFiber) {
+                    null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), 
+                    null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), 
+                    returnFiber.lastEffect = workInProgress.lastEffect);
+                    workInProgress.effectTag > PerformedWork && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, 
+                    returnFiber.lastEffect = workInProgress);
+                }
+                if (stopWorkTimer(workInProgress), !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCompleteWork(workInProgress), 
+                null !== siblingFiber) return siblingFiber;
+                if (null === returnFiber) return pendingCommit = workInProgress, null;
+                workInProgress = returnFiber;
+            }
+            return null;
+        }
+        function performUnitOfWork(workInProgress) {
+            var current = workInProgress.alternate;
+            startWorkTimer(workInProgress);
+            var next = beginWork(current, workInProgress, nextPriorityLevel);
+            return !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onBeginWork(workInProgress), 
+            null === next && (next = completeUnitOfWork(workInProgress)), ReactCurrentOwner$1.current = null, 
+            ReactDebugCurrentFiber$3.resetCurrentFiber(), next;
+        }
+        function performFailedUnitOfWork(workInProgress) {
+            var current = workInProgress.alternate;
+            startWorkTimer(workInProgress);
+            var next = beginFailedWork(current, workInProgress, nextPriorityLevel);
+            return !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onBeginWork(workInProgress), 
+            null === next && (next = completeUnitOfWork(workInProgress)), ReactCurrentOwner$1.current = null, 
+            ReactDebugCurrentFiber$3.resetCurrentFiber(), next;
+        }
+        function performDeferredWork(deadline) {
+            performWork(OffscreenPriority, deadline);
+        }
+        function handleCommitPhaseErrors() {
+            if (null !== capturedErrors && capturedErrors.size > 0 && nextPriorityLevel === TaskPriority$1) for (;null !== nextUnitOfWork && (null !== (nextUnitOfWork = hasCapturedError(nextUnitOfWork) ? performFailedUnitOfWork(nextUnitOfWork) : performUnitOfWork(nextUnitOfWork)) || (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+            priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+            null !== capturedErrors && 0 !== capturedErrors.size && nextPriorityLevel === TaskPriority$1)); ) ;
+        }
+        function workLoop(minPriorityLevel, deadline) {
+            if (null !== pendingCommit ? (priorityContext = TaskPriority$1, commitAllWork(pendingCommit), 
+            handleCommitPhaseErrors()) : null === nextUnitOfWork && resetNextUnitOfWork(), !(nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel)) {
+                priorityContext = nextPriorityLevel;
+                loop: do {
+                    if (nextPriorityLevel <= TaskPriority$1) for (;null !== nextUnitOfWork && !(null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+                    priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+                    handleCommitPhaseErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel > TaskPriority$1)); ) ; else if (null !== deadline) for (;null !== nextUnitOfWork && !deadlineHasExpired; ) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+                        if (null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork))) if (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+                        deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+                            if (priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+                            handleCommitPhaseErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel < HighPriority) break;
+                        } else deadlineHasExpired = !0;
+                    } else deadlineHasExpired = !0;
+                    switch (nextPriorityLevel) {
+                      case SynchronousPriority$1:
+                      case TaskPriority$1:
+                        if (nextPriorityLevel <= minPriorityLevel) continue loop;
+                        break loop;
+
+                      case HighPriority:
+                      case LowPriority:
+                      case OffscreenPriority:
+                        if (null === deadline) break loop;
+                        if (!deadlineHasExpired && nextPriorityLevel <= minPriorityLevel) continue loop;
+                        break loop;
+
+                      case NoWork$2:
+                        break loop;
+
+                      default:
+                        invariant(!1, "Switch statement should be exhuastive. " + "This error is likely caused by a bug in React. Please file an issue.");
+                    }
+                } while (!0);
+            }
+        }
+        function performWorkCatchBlock(failedWork, boundary, minPriorityLevel, deadline) {
+            unwindContexts(failedWork, boundary), nextUnitOfWork = performFailedUnitOfWork(boundary), 
+            workLoop(minPriorityLevel, deadline);
+        }
+        function performWork(minPriorityLevel, deadline) {
+            startWorkLoopTimer(), invariant(!isPerformingWork, "performWork was called recursively. This error is likely caused " + "by a bug in React. Please file an issue."), 
+            isPerformingWork = !0, nestedUpdateCount = 0;
+            var previousPriorityContext = priorityContext, didError = !1, error = null;
+            for (invokeGuardedCallback$1(null, workLoop, null, minPriorityLevel, deadline), 
+            hasCaughtError() && (didError = !0, error = clearCaughtError()); didError; ) {
+                if (didFatal) {
+                    firstUncaughtError = error;
+                    break;
+                }
+                var failedWork = nextUnitOfWork;
+                if (null !== failedWork) {
+                    var boundary = captureError(failedWork, error);
+                    if (invariant(null !== boundary, "Should have found an error boundary. This error is likely " + "caused by a bug in React. Please file an issue."), 
+                    !didFatal) {
+                        if (didError = !1, error = null, invokeGuardedCallback$1(null, performWorkCatchBlock, null, failedWork, boundary, minPriorityLevel, deadline), 
+                        !hasCaughtError()) break;
+                        didError = !0, error = clearCaughtError();
+                    }
+                } else didFatal = !0;
+            }
+            priorityContext = previousPriorityContext, null !== deadline && (isCallbackScheduled = !1), 
+            nextPriorityLevel > TaskPriority$1 && !isCallbackScheduled && (scheduleDeferredCallback(performDeferredWork), 
+            isCallbackScheduled = !0);
+            var errorToThrow = firstUncaughtError;
+            if (isPerformingWork = !1, deadlineHasExpired = !1, didFatal = !1, firstUncaughtError = null, 
+            capturedErrors = null, failedBoundaries = null, stopWorkLoopTimer(), null !== errorToThrow) throw errorToThrow;
+        }
+        function captureError(failedWork, error) {
+            ReactCurrentOwner$1.current = null, ReactDebugCurrentFiber$3.resetCurrentFiber();
+            var boundary = null, errorBoundaryFound = !1, willRetry = !1, errorBoundaryName = null;
+            if (failedWork.tag === HostRoot$5) boundary = failedWork, isFailedBoundary(failedWork) && (didFatal = !0); else for (var node = failedWork.return; null !== node && null === boundary; ) {
+                if (node.tag === ClassComponent$5) {
+                    var instance = node.stateNode;
+                    "function" == typeof instance.componentDidCatch && (errorBoundaryFound = !0, errorBoundaryName = getComponentName_1(node), 
+                    boundary = node, willRetry = !0);
+                } else node.tag === HostRoot$5 && (boundary = node);
+                if (isFailedBoundary(node)) {
+                    if (isUnmounting) return null;
+                    if (null !== commitPhaseBoundaries && (commitPhaseBoundaries.has(node) || null !== node.alternate && commitPhaseBoundaries.has(node.alternate))) return null;
+                    boundary = null, willRetry = !1;
+                }
+                node = node.return;
+            }
+            if (null !== boundary) {
+                null === failedBoundaries && (failedBoundaries = new Set()), failedBoundaries.add(boundary);
+                var _componentStack = getStackAddendumByWorkInProgressFiber$2(failedWork), _componentName = getComponentName_1(failedWork);
+                null === capturedErrors && (capturedErrors = new Map());
+                var capturedError = {
+                    componentName: _componentName,
+                    componentStack: _componentStack,
+                    error: error,
+                    errorBoundary: errorBoundaryFound ? boundary.stateNode : null,
+                    errorBoundaryFound: errorBoundaryFound,
+                    errorBoundaryName: errorBoundaryName,
+                    willRetry: willRetry
+                };
+                capturedErrors.set(boundary, capturedError);
+                try {
+                    logCapturedError$1(capturedError);
+                } catch (e) {
+                    console.error(e);
+                }
+                return isCommitting ? (null === commitPhaseBoundaries && (commitPhaseBoundaries = new Set()), 
+                commitPhaseBoundaries.add(boundary)) : scheduleErrorRecovery(boundary), boundary;
+            }
+            return null === firstUncaughtError && (firstUncaughtError = error), null;
+        }
+        function hasCapturedError(fiber) {
+            return null !== capturedErrors && (capturedErrors.has(fiber) || null !== fiber.alternate && capturedErrors.has(fiber.alternate));
+        }
+        function isFailedBoundary(fiber) {
+            return null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== fiber.alternate && failedBoundaries.has(fiber.alternate));
+        }
+        function commitErrorHandling(effectfulFiber) {
+            var capturedError = void 0;
+            switch (null !== capturedErrors && (capturedError = capturedErrors.get(effectfulFiber), 
+            capturedErrors.delete(effectfulFiber), null == capturedError && null !== effectfulFiber.alternate && (effectfulFiber = effectfulFiber.alternate, 
+            capturedError = capturedErrors.get(effectfulFiber), capturedErrors.delete(effectfulFiber))), 
+            invariant(null != capturedError, "No error for given unit of work. This error is likely caused by a " + "bug in React. Please file an issue."), 
+            effectfulFiber.tag) {
+              case ClassComponent$5:
+                var instance = effectfulFiber.stateNode, info = {
+                    componentStack: capturedError.componentStack
+                };
+                return void instance.componentDidCatch(capturedError.error, info);
+
+              case HostRoot$5:
+                return void (null === firstUncaughtError && (firstUncaughtError = capturedError.error));
+
+              default:
+                invariant(!1, "Invalid type of work. This error is likely caused by a bug in " + "React. Please file an issue.");
+            }
+        }
+        function unwindContexts(from, to) {
+            for (var node = from; null !== node; ) {
+                switch (node.tag) {
+                  case ClassComponent$5:
+                    popContextProvider$1(node);
+                    break;
+
+                  case HostComponent$5:
+                    popHostContext(node);
+                    break;
+
+                  case HostRoot$5:
+                  case HostPortal$3:
+                    popHostContainer(node);
+                }
+                if (node === to || node.alternate === to) {
+                    stopFailedWorkTimer(node);
+                    break;
+                }
+                stopWorkTimer(node), node = node.return;
+            }
+        }
+        function scheduleRoot(root, priorityLevel) {
+            priorityLevel !== NoWork$2 && (root.isScheduled || (root.isScheduled = !0, lastScheduledRoot ? (lastScheduledRoot.nextScheduledRoot = root, 
+            lastScheduledRoot = root) : (nextScheduledRoot = root, lastScheduledRoot = root)));
+        }
+        function scheduleUpdate(fiber, priorityLevel) {
+            return scheduleUpdateImpl(fiber, priorityLevel, !1);
+        }
+        function scheduleUpdateImpl(fiber, priorityLevel, isErrorRecovery) {
+            if (recordScheduleUpdate(), nestedUpdateCount > NESTED_UPDATE_LIMIT && (didFatal = !0, 
+            invariant(!1, "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.")), 
+            !isPerformingWork && priorityLevel <= nextPriorityLevel && (nextUnitOfWork = null), 
+            !isErrorRecovery && fiber.tag === ClassComponent$5) {
+                var instance = fiber.stateNode;
+                warnAboutInvalidUpdates(instance);
+            }
+            for (var node = fiber, shouldContinue = !0; null !== node && shouldContinue; ) {
+                if (shouldContinue = !1, (node.pendingWorkPriority === NoWork$2 || node.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
+                node.pendingWorkPriority = priorityLevel), null !== node.alternate && (node.alternate.pendingWorkPriority === NoWork$2 || node.alternate.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
+                node.alternate.pendingWorkPriority = priorityLevel), null === node.return) {
+                    if (node.tag !== HostRoot$5) return void (isErrorRecovery || fiber.tag !== ClassComponent$5 || warnAboutUpdateOnUnmounted(fiber.stateNode));
+                    if (scheduleRoot(node.stateNode, priorityLevel), !isPerformingWork) switch (priorityLevel) {
+                      case SynchronousPriority$1:
+                        isUnbatchingUpdates ? performWork(SynchronousPriority$1, null) : performWork(TaskPriority$1, null);
+                        break;
+
+                      case TaskPriority$1:
+                        invariant(isBatchingUpdates, "Task updates can only be scheduled as a nested update or " + "inside batchedUpdates.");
+                        break;
+
+                      default:
+                        isCallbackScheduled || (scheduleDeferredCallback(performDeferredWork), isCallbackScheduled = !0);
+                    }
+                }
+                node = node.return;
+            }
+        }
+        function getPriorityContext(fiber, forceAsync) {
+            var priorityLevel = priorityContext;
+            return priorityLevel === NoWork$2 && (priorityLevel = !useSyncScheduling || fiber.internalContextTag & AsyncUpdates || forceAsync ? LowPriority : SynchronousPriority$1), 
+            priorityLevel === SynchronousPriority$1 && (isPerformingWork || isBatchingUpdates) ? TaskPriority$1 : priorityLevel;
+        }
+        function scheduleErrorRecovery(fiber) {
+            scheduleUpdateImpl(fiber, TaskPriority$1, !0);
+        }
+        function performWithPriority(priorityLevel, fn) {
+            var previousPriorityContext = priorityContext;
+            priorityContext = priorityLevel;
+            try {
+                fn();
+            } finally {
+                priorityContext = previousPriorityContext;
+            }
+        }
+        function batchedUpdates(fn, a) {
+            var previousIsBatchingUpdates = isBatchingUpdates;
+            isBatchingUpdates = !0;
+            try {
+                return fn(a);
+            } finally {
+                isBatchingUpdates = previousIsBatchingUpdates, isPerformingWork || isBatchingUpdates || performWork(TaskPriority$1, null);
+            }
+        }
+        function unbatchedUpdates(fn) {
+            var previousIsUnbatchingUpdates = isUnbatchingUpdates, previousIsBatchingUpdates = isBatchingUpdates;
+            isUnbatchingUpdates = isBatchingUpdates, isBatchingUpdates = !1;
+            try {
+                return fn();
+            } finally {
+                isBatchingUpdates = previousIsBatchingUpdates, isUnbatchingUpdates = previousIsUnbatchingUpdates;
+            }
+        }
+        function flushSync(batch) {
+            var previousIsBatchingUpdates = isBatchingUpdates, previousPriorityContext = priorityContext;
+            isBatchingUpdates = !0, priorityContext = SynchronousPriority$1;
+            try {
+                return batch();
+            } finally {
+                isBatchingUpdates = previousIsBatchingUpdates, priorityContext = previousPriorityContext, 
+                invariant(!isPerformingWork, "flushSync was called from inside a lifecycle method. It cannot be " + "called when React is already rendering."), 
+                performWork(TaskPriority$1, null);
+            }
+        }
+        function deferredUpdates(fn) {
+            var previousPriorityContext = priorityContext;
+            priorityContext = LowPriority;
+            try {
+                return fn();
+            } finally {
+                priorityContext = previousPriorityContext;
+            }
+        }
+        return {
+            scheduleUpdate: scheduleUpdate,
+            getPriorityContext: getPriorityContext,
+            performWithPriority: performWithPriority,
+            batchedUpdates: batchedUpdates,
+            unbatchedUpdates: unbatchedUpdates,
+            flushSync: flushSync,
+            deferredUpdates: deferredUpdates
+        };
+    }, getContextFiber = function(arg) {
+        invariant(!1, "Missing injection for fiber getContextForSubtree");
+    };
+    function getContextForSubtree(parentComponent) {
+        if (!parentComponent) return emptyObject;
+        var instance = ReactInstanceMap_1.get(parentComponent);
+        return "number" == typeof instance.tag ? getContextFiber(instance) : instance._processChildContext(instance._context);
     }
-}, EventPluginHub_1 = EventPluginHub, ReactTypeOfWork = {
-    IndeterminateComponent: 0,
-    FunctionalComponent: 1,
-    ClassComponent: 2,
-    HostRoot: 3,
-    HostPortal: 4,
-    HostComponent: 5,
-    HostText: 6,
-    CoroutineComponent: 7,
-    CoroutineHandlerPhase: 8,
-    YieldComponent: 9,
-    Fragment: 10
-}, HostComponent = ReactTypeOfWork.HostComponent;
-
-function getParent(inst) {
-    if (void 0 !== inst._hostParent) return inst._hostParent;
-    if ("number" == typeof inst.tag) {
-        do {
-            inst = inst.return;
-        } while (inst && inst.tag !== HostComponent);
-        if (inst) return inst;
+    getContextForSubtree._injectFiber = function(fn) {
+        getContextFiber = fn;
+    };
+    var getContextForSubtree_1 = getContextForSubtree, addTopLevelUpdate = ReactFiberUpdateQueue.addTopLevelUpdate, findCurrentUnmaskedContext = ReactFiberContext.findCurrentUnmaskedContext, isContextProvider = ReactFiberContext.isContextProvider, processChildContext = ReactFiberContext.processChildContext, createFiberRoot = ReactFiberRoot.createFiberRoot, HostComponent = ReactTypeOfWork.HostComponent, warning$1 = require$$0, ReactFiberInstrumentation = ReactFiberInstrumentation_1, ReactDebugCurrentFiber = ReactDebugCurrentFiber_1, getComponentName = getComponentName_1, findCurrentHostFiber = ReactFiberTreeReflection.findCurrentHostFiber, findCurrentHostFiberWithNoPortals = ReactFiberTreeReflection.findCurrentHostFiberWithNoPortals;
+    getContextForSubtree_1._injectFiber(function(fiber) {
+        var parentContext = findCurrentUnmaskedContext(fiber);
+        return isContextProvider(fiber) ? processChildContext(fiber, parentContext, !1) : parentContext;
+    });
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
     }
-    return null;
-}
-
-function getLowestCommonAncestor(instA, instB) {
-    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
-    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
-    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
-    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
-    for (var depth = depthA; depth--; ) {
-        if (instA === instB || instA === instB.alternate) return instA;
-        instA = getParent(instA), instB = getParent(instB);
+    var objects = {}, uniqueID = 1, emptyObject$3 = {}, ReactNativePropRegistry = function() {
+        function ReactNativePropRegistry() {
+            _classCallCheck(this, ReactNativePropRegistry);
+        }
+        return ReactNativePropRegistry.register = function(object) {
+            var id = ++uniqueID;
+            return Object.freeze(object), objects[id] = object, id;
+        }, ReactNativePropRegistry.getByID = function(id) {
+            if (!id) return emptyObject$3;
+            var object = objects[id];
+            return object || (console.warn("Invalid style with id `" + id + "`. Skipping ..."), 
+            emptyObject$3);
+        }, ReactNativePropRegistry;
+    }(), ReactNativePropRegistry_1 = ReactNativePropRegistry, emptyObject$2 = {}, removedKeys = null, removedKeyCount = 0;
+    function defaultDiffer(prevProp, nextProp) {
+        return "object" != typeof nextProp || null === nextProp || deepDiffer(prevProp, nextProp);
     }
-    return null;
-}
-
-function isAncestor(instA, instB) {
-    for (;instB; ) {
-        if (instA === instB || instA === instB.alternate) return !0;
-        instB = getParent(instB);
+    function resolveObject(idOrObject) {
+        return "number" == typeof idOrObject ? ReactNativePropRegistry_1.getByID(idOrObject) : idOrObject;
     }
-    return !1;
-}
-
-function getParentInstance(inst) {
-    return getParent(inst);
-}
-
-function traverseTwoPhase(inst, fn, arg) {
-    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
-    var i;
-    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
-    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
-}
-
-function traverseEnterLeave(from, to, fn, argFrom, argTo) {
-    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
-    from = getParent(from);
-    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
-    var i;
-    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
-    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
-}
-
-var ReactTreeTraversal = {
-    isAncestor: isAncestor,
-    getLowestCommonAncestor: getLowestCommonAncestor,
-    getParentInstance: getParentInstance,
-    traverseTwoPhase: traverseTwoPhase,
-    traverseEnterLeave: traverseEnterLeave
-}, getListener = EventPluginHub_1.getListener;
-
-function listenerAtPhase(inst, event, propagationPhase) {
-    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
-    return getListener(inst, registrationName);
-}
-
-function accumulateDirectionalDispatches(inst, phase, event) {
-    warning(inst, "Dispatching inst must not be null");
-    var listener = listenerAtPhase(inst, event, phase);
-    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-}
-
-function accumulateTwoPhaseDispatchesSingle(event) {
-    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
-}
-
-function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
-    if (event && event.dispatchConfig.phasedRegistrationNames) {
-        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
-        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+    function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+        if (Array.isArray(node)) for (var i = node.length; i-- && removedKeyCount > 0; ) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes); else if (node && removedKeyCount > 0) {
+            var obj = resolveObject(node);
+            for (var propKey in removedKeys) if (removedKeys[propKey]) {
+                var nextProp = obj[propKey];
+                if (void 0 !== nextProp) {
+                    var attributeConfig = validAttributes[propKey];
+                    if (attributeConfig) {
+                        if ("function" == typeof nextProp && (nextProp = !0), void 0 === nextProp && (nextProp = null), 
+                        "object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+                            var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
+                            updatePayload[propKey] = nextValue;
+                        }
+                        removedKeys[propKey] = !1, removedKeyCount--;
+                    }
+                }
+            }
+        }
     }
-}
+    function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
+        var i, minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
+        for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
+        for (;i < prevArray.length; i++) updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
+        for (;i < nextArray.length; i++) updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
+        return updatePayload;
+    }
+    function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+        return updatePayload || prevProp !== nextProp ? prevProp && nextProp ? Array.isArray(prevProp) || Array.isArray(nextProp) ? Array.isArray(prevProp) && Array.isArray(nextProp) ? diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes) : Array.isArray(prevProp) ? diffProperties(updatePayload, flattenStyle(prevProp), resolveObject(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), flattenStyle(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), resolveObject(nextProp), validAttributes) : nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload : updatePayload;
+    }
+    function addNestedProperty(updatePayload, nextProp, validAttributes) {
+        if (!nextProp) return updatePayload;
+        if (!Array.isArray(nextProp)) return addProperties(updatePayload, resolveObject(nextProp), validAttributes);
+        for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+        return updatePayload;
+    }
+    function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+        if (!prevProp) return updatePayload;
+        if (!Array.isArray(prevProp)) return clearProperties(updatePayload, resolveObject(prevProp), validAttributes);
+        for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+        return updatePayload;
+    }
+    function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+        var attributeConfig, nextProp, prevProp;
+        for (var propKey in nextProps) if (attributeConfig = validAttributes[propKey]) if (prevProp = prevProps[propKey], 
+        nextProp = nextProps[propKey], "function" == typeof nextProp && (nextProp = !0, 
+        "function" == typeof prevProp && (prevProp = !0)), void 0 === nextProp && (nextProp = null, 
+        void 0 === prevProp && (prevProp = null)), removedKeys && (removedKeys[propKey] = !1), 
+        updatePayload && void 0 !== updatePayload[propKey]) {
+            if ("object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+                var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
+                updatePayload[propKey] = nextValue;
+            }
+        } else if (prevProp !== nextProp) if ("object" != typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp); else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+            var shouldUpdate = void 0 === prevProp || ("function" == typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));
+            shouldUpdate && (nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, 
+            (updatePayload || (updatePayload = {}))[propKey] = nextValue);
+        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 
+        removedKeyCount > 0 && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), 
+        removedKeys = null);
+        for (propKey in prevProps) void 0 === nextProps[propKey] && (attributeConfig = validAttributes[propKey]) && (updatePayload && void 0 !== updatePayload[propKey] || void 0 !== (prevProp = prevProps[propKey]) && ("object" != typeof attributeConfig || "function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey] = null, 
+        removedKeys || (removedKeys = {}), removedKeys[propKey] || (removedKeys[propKey] = !0, 
+        removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig)));
+        return updatePayload;
+    }
+    function addProperties(updatePayload, props, validAttributes) {
+        return diffProperties(updatePayload, emptyObject$2, props, validAttributes);
+    }
+    function clearProperties(updatePayload, prevProps, validAttributes) {
+        return diffProperties(updatePayload, prevProps, emptyObject$2, validAttributes);
+    }
+    var ReactNativeAttributePayload = {
+        create: function(props, validAttributes) {
+            return addProperties(null, props, validAttributes);
+        },
+        diff: function(prevProps, nextProps, validAttributes) {
+            return diffProperties(null, prevProps, nextProps, validAttributes);
+        }
+    }, ReactNativeAttributePayload_1 = ReactNativeAttributePayload;
+    function mountSafeCallback$1(context, callback) {
+        return function() {
+            if (callback) {
+                if ("boolean" == typeof context.__isMounted) {
+                    if (!context.__isMounted) return;
+                } else if ("function" == typeof context.isMounted && !context.isMounted()) return;
+                return callback.apply(context, arguments);
+            }
+        };
+    }
+    function throwOnStylesProp(component, props) {
+        if (void 0 !== props.styles) {
+            var owner = component._owner || null, name = component.constructor.displayName, msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+            throw owner && owner.constructor && owner.constructor.displayName && (msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component."), 
+            new Error(msg);
+        }
+    }
+    function warnForStyleProps$1(props, validAttributes) {
+        for (var key in validAttributes.style) validAttributes[key] || void 0 === props[key] || console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+    }
+    var NativeMethodsMixinUtils = {
+        mountSafeCallback: mountSafeCallback$1,
+        throwOnStylesProp: throwOnStylesProp,
+        warnForStyleProps: warnForStyleProps$1
+    };
+    function _classCallCheck$1(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    var mountSafeCallback = NativeMethodsMixinUtils.mountSafeCallback, warnForStyleProps = NativeMethodsMixinUtils.warnForStyleProps, ReactNativeFiberHostComponent = function() {
+        function ReactNativeFiberHostComponent(tag, viewConfig) {
+            _classCallCheck$1(this, ReactNativeFiberHostComponent), this._nativeTag = tag, this._children = [], 
+            this.viewConfig = viewConfig;
+        }
+        return ReactNativeFiberHostComponent.prototype.blur = function() {
+            TextInputState.blurTextInput(this._nativeTag);
+        }, ReactNativeFiberHostComponent.prototype.focus = function() {
+            TextInputState.focusTextInput(this._nativeTag);
+        }, ReactNativeFiberHostComponent.prototype.measure = function(callback) {
+            UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
+        }, ReactNativeFiberHostComponent.prototype.measureInWindow = function(callback) {
+            UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
+        }, ReactNativeFiberHostComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
+            UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
+        }, ReactNativeFiberHostComponent.prototype.setNativeProps = function(nativeProps) {
+            warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
+            var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, this.viewConfig.validAttributes);
+            UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
+        }, ReactNativeFiberHostComponent;
+    }(), ReactNativeFiberHostComponent_1 = ReactNativeFiberHostComponent, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
+        tagsStartAt: INITIAL_TAG_COUNT,
+        tagCount: INITIAL_TAG_COUNT,
+        allocateTag: function() {
+            for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
+            var tag = ReactNativeTagHandles.tagCount;
+            return ReactNativeTagHandles.tagCount++, tag;
+        },
+        assertRootTag: function(tag) {
+            invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
+        },
+        reactTagIsNativeTopRootID: function(reactTag) {
+            return reactTag % 10 == 1;
+        }
+    }, ReactNativeTagHandles_1 = ReactNativeTagHandles, viewConfigs = new Map(), ReactNativeViewConfigRegistry = {
+        register: function(viewConfig) {
+            var name = viewConfig.uiViewClassName;
+            return invariant(!viewConfigs.has(name), "Tried to register two views with the same name %s", name), 
+            viewConfigs.set(name, viewConfig), name;
+        },
+        get: function(name) {
+            var config = viewConfigs.get(name);
+            return invariant(config, "View config not found for name %s", name), config;
+        }
+    }, ReactNativeViewConfigRegistry_1 = ReactNativeViewConfigRegistry, precacheFiberNode$1 = ReactNativeComponentTree_1.precacheFiberNode, uncacheFiberNode$1 = ReactNativeComponentTree_1.uncacheFiberNode, updateFiberProps$1 = ReactNativeComponentTree_1.updateFiberProps;
+    function recursivelyUncacheFiberNode(node) {
+        "number" == typeof node ? uncacheFiberNode$1(node) : (uncacheFiberNode$1(node._nativeTag), 
+        node._children.forEach(recursivelyUncacheFiberNode));
+    }
+    var NativeRenderer = function(config) {
+        var getPublicInstance = config.getPublicInstance, _ReactFiberScheduler = ReactFiberScheduler(config), scheduleUpdate = _ReactFiberScheduler.scheduleUpdate, getPriorityContext = _ReactFiberScheduler.getPriorityContext, performWithPriority = _ReactFiberScheduler.performWithPriority, batchedUpdates = _ReactFiberScheduler.batchedUpdates, unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates, flushSync = _ReactFiberScheduler.flushSync, deferredUpdates = _ReactFiberScheduler.deferredUpdates;
+        function scheduleTopLevelUpdate(current, element, callback) {
+            "render" === ReactDebugCurrentFiber.phase && null !== ReactDebugCurrentFiber.current && warning$1(!1, "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");
+            var forceAsync = ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != element && null != element.type && null != element.type.prototype && !0 === element.type.prototype.unstable_isAsyncReactComponent, priorityLevel = getPriorityContext(current, forceAsync), nextState = {
+                element: element
+            };
+            callback = void 0 === callback ? null : callback, warning$1(null === callback || "function" == typeof callback, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback), 
+            addTopLevelUpdate(current, nextState, callback, priorityLevel), scheduleUpdate(current, priorityLevel);
+        }
+        return {
+            createContainer: function(containerInfo) {
+                return createFiberRoot(containerInfo);
+            },
+            updateContainer: function(element, container, parentComponent, callback) {
+                var current = container.current;
+                ReactFiberInstrumentation.debugTool && (null === current.alternate ? ReactFiberInstrumentation.debugTool.onMountContainer(container) : null === element ? ReactFiberInstrumentation.debugTool.onUnmountContainer(container) : ReactFiberInstrumentation.debugTool.onUpdateContainer(container));
+                var context = getContextForSubtree_1(parentComponent);
+                null === container.context ? container.context = context : container.pendingContext = context, 
+                scheduleTopLevelUpdate(current, element, callback);
+            },
+            performWithPriority: performWithPriority,
+            batchedUpdates: batchedUpdates,
+            unbatchedUpdates: unbatchedUpdates,
+            deferredUpdates: deferredUpdates,
+            flushSync: flushSync,
+            getPublicRootInstance: function(container) {
+                var containerFiber = container.current;
+                if (!containerFiber.child) return null;
+                switch (containerFiber.child.tag) {
+                  case HostComponent:
+                    return getPublicInstance(containerFiber.child.stateNode);
 
-function accumulateDispatches(inst, ignoredDirection, event) {
-    if (inst && event && event.dispatchConfig.registrationName) {
-        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+                  default:
+                    return containerFiber.child.stateNode;
+                }
+            },
+            findHostInstance: function(fiber) {
+                var hostFiber = findCurrentHostFiber(fiber);
+                return null === hostFiber ? null : hostFiber.stateNode;
+            },
+            findHostInstanceWithNoPortals: function(fiber) {
+                var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
+                return null === hostFiber ? null : hostFiber.stateNode;
+            }
+        };
+    }({
+        appendChild: function(parentInstance, child) {
+            var childTag = "number" == typeof child ? child : child._nativeTag, children = parentInstance._children, index = children.indexOf(child);
+            index >= 0 ? (children.splice(index, 1), children.push(child), UIManager.manageChildren(parentInstance._nativeTag, [ index ], [ children.length - 1 ], [], [], [])) : (children.push(child), 
+            UIManager.manageChildren(parentInstance._nativeTag, [], [], [ childTag ], [ children.length - 1 ], []));
+        },
+        appendChildToContainer: function(parentInstance, child) {
+            var childTag = "number" == typeof child ? child : child._nativeTag;
+            UIManager.setChildren(parentInstance, [ childTag ]);
+        },
+        appendInitialChild: function(parentInstance, child) {
+            parentInstance._children.push(child);
+        },
+        commitTextUpdate: function(textInstance, oldText, newText) {
+            UIManager.updateView(textInstance, "RCTRawText", {
+                text: newText
+            });
+        },
+        commitMount: function(instance, type, newProps, internalInstanceHandle) {},
+        commitUpdate: function(instance, updatePayloadTODO, type, oldProps, newProps, internalInstanceHandle) {
+            var viewConfig = instance.viewConfig;
+            updateFiberProps$1(instance._nativeTag, newProps);
+            var updatePayload = ReactNativeAttributePayload_1.diff(oldProps, newProps, viewConfig.validAttributes);
+            UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+        },
+        createInstance: function(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
+            var tag = ReactNativeTagHandles_1.allocateTag(), viewConfig = ReactNativeViewConfigRegistry_1.get(type);
+            for (var key in viewConfig.validAttributes) props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(props[key]);
+            var updatePayload = ReactNativeAttributePayload_1.create(props, viewConfig.validAttributes);
+            UIManager.createView(tag, viewConfig.uiViewClassName, rootContainerInstance, updatePayload);
+            var component = new ReactNativeFiberHostComponent_1(tag, viewConfig);
+            return precacheFiberNode$1(internalInstanceHandle, tag), updateFiberProps$1(tag, props), 
+            component;
+        },
+        createTextInstance: function(text, rootContainerInstance, hostContext, internalInstanceHandle) {
+            var tag = ReactNativeTagHandles_1.allocateTag();
+            return UIManager.createView(tag, "RCTRawText", rootContainerInstance, {
+                text: text
+            }), precacheFiberNode$1(internalInstanceHandle, tag), tag;
+        },
+        finalizeInitialChildren: function(parentInstance, type, props, rootContainerInstance) {
+            if (0 === parentInstance._children.length) return !1;
+            var nativeTags = parentInstance._children.map(function(child) {
+                return "number" == typeof child ? child : child._nativeTag;
+            });
+            return UIManager.setChildren(parentInstance._nativeTag, nativeTags), !1;
+        },
+        getRootHostContext: function() {
+            return emptyObject;
+        },
+        getChildHostContext: function() {
+            return emptyObject;
+        },
+        getPublicInstance: function(instance) {
+            return instance;
+        },
+        insertBefore: function(parentInstance, child, beforeChild) {
+            var children = parentInstance._children, index = children.indexOf(child);
+            if (index >= 0) {
+                children.splice(index, 1);
+                var beforeChildIndex = children.indexOf(beforeChild);
+                children.splice(beforeChildIndex, 0, child), UIManager.manageChildren(parentInstance._nativeTag, [ index ], [ beforeChildIndex ], [], [], []);
+            } else {
+                var _beforeChildIndex = children.indexOf(beforeChild);
+                children.splice(_beforeChildIndex, 0, child);
+                var childTag = "number" == typeof child ? child : child._nativeTag;
+                UIManager.manageChildren(parentInstance._nativeTag, [], [], [ childTag ], [ _beforeChildIndex ], []);
+            }
+        },
+        insertInContainerBefore: function(parentInstance, child, beforeChild) {
+            invariant("number" != typeof parentInstance, "Container does not support insertBefore operation");
+        },
+        prepareForCommit: function() {},
+        prepareUpdate: function(instance, type, oldProps, newProps, rootContainerInstance, hostContext) {
+            return emptyObject;
+        },
+        removeChild: function(parentInstance, child) {
+            recursivelyUncacheFiberNode(child);
+            var children = parentInstance._children, index = children.indexOf(child);
+            children.splice(index, 1), UIManager.manageChildren(parentInstance._nativeTag, [], [], [], [], [ index ]);
+        },
+        removeChildFromContainer: function(parentInstance, child) {
+            recursivelyUncacheFiberNode(child), UIManager.manageChildren(parentInstance, [], [], [], [], [ 0 ]);
+        },
+        resetAfterCommit: function() {},
+        resetTextContent: function(instance) {},
+        shouldDeprioritizeSubtree: function(type, props) {
+            return !1;
+        },
+        scheduleDeferredCallback: commonjsGlobal.requestIdleCallback,
+        shouldSetTextContent: function(type, props) {
+            return !1;
+        },
+        useSyncScheduling: !0
+    }), ReactNativeFiberRenderer = NativeRenderer, getClosestInstanceFromNode = ReactNativeComponentTree_1.getClosestInstanceFromNode, findCurrentFiberUsingSlowPath$1 = ReactFiberTreeReflection.findCurrentFiberUsingSlowPath, HostComponent$10 = ReactTypeOfWork.HostComponent, getInspectorDataForViewTag = void 0, traverseOwnerTreeUp = function(hierarchy, instance) {
+        instance && (hierarchy.unshift(instance), traverseOwnerTreeUp(hierarchy, instance._debugOwner));
+    }, getOwnerHierarchy = function(instance) {
+        var hierarchy = [];
+        return traverseOwnerTreeUp(hierarchy, instance), hierarchy;
+    }, lastNonHostInstance = function(hierarchy) {
+        for (var i = hierarchy.length - 1; i > 1; i--) {
+            var instance = hierarchy[i];
+            if (instance.tag !== HostComponent$10) return instance;
+        }
+        return hierarchy[0];
+    }, getHostProps = function(fiber) {
+        var host = ReactFiberTreeReflection.findCurrentHostFiber(fiber);
+        return host ? host.memoizedProps || emptyObject : emptyObject;
+    }, getHostNode = function(fiber, findNodeHandle) {
+        for (var hostNode = void 0; fiber; ) {
+            if (null !== fiber.stateNode && fiber.tag === HostComponent$10 && (hostNode = findNodeHandle(fiber.stateNode)), 
+            hostNode) return hostNode;
+            fiber = fiber.child;
+        }
+        return null;
+    }, createHierarchy = function(fiberHierarchy) {
+        return fiberHierarchy.map(function(fiber) {
+            return {
+                name: getComponentName_1(fiber),
+                getInspectorData: function(findNodeHandle) {
+                    return {
+                        measure: function(callback) {
+                            return UIManager.measure(getHostNode(fiber, findNodeHandle), callback);
+                        },
+                        props: getHostProps(fiber),
+                        source: fiber._debugSource
+                    };
+                }
+            };
+        });
+    };
+    getInspectorDataForViewTag = function(viewTag) {
+        var closestInstance = getClosestInstanceFromNode(viewTag);
+        if (!closestInstance) return {
+            hierarchy: [],
+            props: emptyObject,
+            selection: null,
+            source: null
+        };
+        var fiber = findCurrentFiberUsingSlowPath$1(closestInstance), fiberHierarchy = getOwnerHierarchy(fiber), instance = lastNonHostInstance(fiberHierarchy), hierarchy = createHierarchy(fiberHierarchy), props = getHostProps(instance), source = instance._debugSource;
+        return {
+            hierarchy: hierarchy,
+            props: props,
+            selection: fiberHierarchy.indexOf(instance),
+            source: source
+        };
+    };
+    var ReactNativeFiberInspector = {
+        getInspectorDataForViewTag: getInspectorDataForViewTag
+    }, ReactVersion = "16.0.0-beta.5", ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), ReactCurrentOwner$3 = ReactGlobalSharedState_1.ReactCurrentOwner, injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
+        return ReactNativeFiberRenderer.findHostInstance(fiber);
+    } : function(instance) {
+        return instance;
+    };
+    function findNodeHandle(componentOrHandle) {
+        var owner = ReactCurrentOwner$3.current;
+        if (null !== owner && (require$$0(owner._warnedAboutRefsInRender, "%s is accessing findNodeHandle 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.", owner.getName() || "A component"), 
+        owner._warnedAboutRefsInRender = !0), null == componentOrHandle) return null;
+        if ("number" == typeof componentOrHandle) return componentOrHandle;
+        var component = componentOrHandle, internalInstance = ReactInstanceMap_1.get(component);
+        return internalInstance ? injectedFindNode(internalInstance) : component || (invariant("object" == typeof component && ("_rootNodeID" in component || "_nativeTag" in component) || null != component.render && "function" == typeof component.render, "findNodeHandle(...): Argument is not a component " + "(type: %s, keys: %s)", typeof component, Object.keys(component)), 
+        void invariant(!1, "findNodeHandle(...): Unable to find node handle for unmounted " + "component."));
+    }
+    var findNodeHandle_1 = findNodeHandle, findNumericNodeHandleFiber = function(componentOrHandle) {
+        var instance = findNodeHandle_1(componentOrHandle);
+        return null == instance || "number" == typeof instance ? instance : instance._nativeTag;
+    }, eventPluginOrder = null, namesToPlugins = {};
+    function recomputePluginOrdering() {
+        if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+            var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
+            if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
+            !EventPluginRegistry.plugins[pluginIndex]) {
+                invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
+                EventPluginRegistry.plugins[pluginIndex] = pluginModule;
+                var publishedEvents = pluginModule.eventTypes;
+                for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
+            }
+        }
+    }
+    function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
+        invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
+        EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
+        var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+        if (phasedRegistrationNames) {
+            for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
+                var phasedRegistrationName = phasedRegistrationNames[phaseName];
+                publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+            }
+            return !0;
+        }
+        return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
+        !0);
+    }
+    function publishRegistrationName(registrationName, pluginModule, eventName) {
+        invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
+        EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
+        var lowerCasedName = registrationName.toLowerCase();
+        EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName, 
+        "onDoubleClick" === registrationName && (EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName);
+    }
+    var EventPluginRegistry = {
+        plugins: [],
+        eventNameDispatchConfigs: {},
+        registrationNameModules: {},
+        registrationNameDependencies: {},
+        possibleRegistrationNames: {},
+        injectEventPluginOrder: function(injectedEventPluginOrder) {
+            invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
+            eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
+        },
+        injectEventPluginsByName: function(injectedNamesToPlugins) {
+            var isOrderingDirty = !1;
+            for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+                var pluginModule = injectedNamesToPlugins[pluginName];
+                namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
+                namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
+            }
+            isOrderingDirty && recomputePluginOrdering();
+        }
+    }, EventPluginRegistry_1 = EventPluginRegistry;
+    function accumulateInto(current, next) {
+        return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
+        null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
+        current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+    }
+    var accumulateInto_1 = accumulateInto;
+    function forEachAccumulated(arr, cb, scope) {
+        Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+    }
+    var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
+        event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
+    }, executeDispatchesAndReleaseSimulated = function(e) {
+        return executeDispatchesAndRelease(e, !0);
+    }, executeDispatchesAndReleaseTopLevel = function(e) {
+        return executeDispatchesAndRelease(e, !1);
+    };
+    function isInteractive(tag) {
+        return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
+    }
+    function shouldPreventMouseEvent(name, type, props) {
+        switch (name) {
+          case "onClick":
+          case "onClickCapture":
+          case "onDoubleClick":
+          case "onDoubleClickCapture":
+          case "onMouseDown":
+          case "onMouseDownCapture":
+          case "onMouseMove":
+          case "onMouseMoveCapture":
+          case "onMouseUp":
+          case "onMouseUpCapture":
+            return !(!props.disabled || !isInteractive(type));
+
+          default:
+            return !1;
+        }
+    }
+    var EventPluginHub = {
+        injection: {
+            injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
+            injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
+        },
+        getListener: function(inst, registrationName) {
+            var listener;
+            if ("number" == typeof inst.tag) {
+                var stateNode = inst.stateNode;
+                if (!stateNode) return null;
+                var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
+                if (!props) return null;
+                if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
+            } else {
+                var currentElement = inst._currentElement;
+                if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
+                if (!inst._rootNodeID) return null;
+                var _props = currentElement.props;
+                if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
+            }
+            return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
+            listener;
+        },
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
+                var possiblePlugin = plugins[i];
+                if (possiblePlugin) {
+                    var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+                    extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+                }
+            }
+            return events;
+        },
+        enqueueEvents: function(events) {
+            events && (eventQueue = accumulateInto_1(eventQueue, events));
+        },
+        processEventQueue: function(simulated) {
+            var processingEventQueue = eventQueue;
+            eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
+            invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
+            ReactErrorUtils_1.rethrowCaughtError();
+        }
+    }, EventPluginHub_1 = EventPluginHub, HostComponent$11 = ReactTypeOfWork.HostComponent;
+    function getParent(inst) {
+        if (void 0 !== inst._hostParent) return inst._hostParent;
+        if ("number" == typeof inst.tag) {
+            do {
+                inst = inst.return;
+            } while (inst && inst.tag !== HostComponent$11);
+            if (inst) return inst;
+        }
+        return null;
+    }
+    function getLowestCommonAncestor(instA, instB) {
+        for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
+        for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
+        for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
+        for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
+        for (var depth = depthA; depth--; ) {
+            if (instA === instB || instA === instB.alternate) return instA;
+            instA = getParent(instA), instB = getParent(instB);
+        }
+        return null;
+    }
+    function isAncestor(instA, instB) {
+        for (;instB; ) {
+            if (instA === instB || instA === instB.alternate) return !0;
+            instB = getParent(instB);
+        }
+        return !1;
+    }
+    function getParentInstance(inst) {
+        return getParent(inst);
+    }
+    function traverseTwoPhase(inst, fn, arg) {
+        for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
+        var i;
+        for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
+        for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
+    }
+    function traverseEnterLeave(from, to, fn, argFrom, argTo) {
+        for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
+        from = getParent(from);
+        for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
+        var i;
+        for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
+        for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
+    }
+    var ReactTreeTraversal = {
+        isAncestor: isAncestor,
+        getLowestCommonAncestor: getLowestCommonAncestor,
+        getParentInstance: getParentInstance,
+        traverseTwoPhase: traverseTwoPhase,
+        traverseEnterLeave: traverseEnterLeave
+    }, getListener = EventPluginHub_1.getListener, warning$11 = require$$0;
+    function listenerAtPhase(inst, event, propagationPhase) {
+        var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+        return getListener(inst, registrationName);
+    }
+    function accumulateDirectionalDispatches(inst, phase, event) {
+        warning$11(inst, "Dispatching inst must not be null");
+        var listener = listenerAtPhase(inst, event, phase);
         listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
         event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
     }
-}
-
-function accumulateDirectDispatchesSingle(event) {
-    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
-}
-
-function accumulateTwoPhaseDispatches(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
-}
-
-function accumulateTwoPhaseDispatchesSkipTarget(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
-}
-
-function accumulateEnterLeaveDispatches(leave, enter, from, to) {
-    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
-}
-
-function accumulateDirectDispatches(events) {
-    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
-}
-
-var EventPropagators = {
-    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
-    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
-    accumulateDirectDispatches: accumulateDirectDispatches,
-    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
-}, EventPropagators_1 = EventPropagators, oneArgumentPooler = function(copyFieldsFrom) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, copyFieldsFrom), instance;
+    function accumulateTwoPhaseDispatchesSingle(event) {
+        event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
     }
-    return new Klass(copyFieldsFrom);
-}, twoArgumentPooler = function(a1, a2) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2), instance;
-    }
-    return new Klass(a1, a2);
-}, threeArgumentPooler = function(a1, a2, a3) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3), instance;
-    }
-    return new Klass(a1, a2, a3);
-}, fourArgumentPooler = function(a1, a2, a3, a4) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3, a4), instance;
-    }
-    return new Klass(a1, a2, a3, a4);
-}, standardReleaser = function(instance) {
-    var Klass = this;
-    invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
-    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
-}, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
-    var NewKlass = CopyConstructor;
-    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
-    NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
-    NewKlass;
-}, PooledClass = {
-    addPoolingTo: addPoolingTo,
-    oneArgumentPooler: oneArgumentPooler,
-    twoArgumentPooler: twoArgumentPooler,
-    threeArgumentPooler: threeArgumentPooler,
-    fourArgumentPooler: fourArgumentPooler
-}, PooledClass_1 = PooledClass, didWarnForAddedNewProperty = !1, isProxySupported = "function" == typeof Proxy, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
-    type: null,
-    target: null,
-    currentTarget: emptyFunction.thatReturnsNull,
-    eventPhase: null,
-    bubbles: null,
-    cancelable: null,
-    timeStamp: function(event) {
-        return event.timeStamp || Date.now();
-    },
-    defaultPrevented: null,
-    isTrusted: null
-};
-
-function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
-    delete this.nativeEvent, delete this.preventDefault, delete this.stopPropagation, 
-    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
-    var Interface = this.constructor.Interface;
-    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
-        delete this[propName];
-        var normalize = Interface[propName];
-        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
-    }
-    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
-    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
-    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
-}
-
-Object.assign(SyntheticEvent.prototype, {
-    preventDefault: function() {
-        this.defaultPrevented = !0;
-        var event = this.nativeEvent;
-        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
-        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
-    },
-    stopPropagation: function() {
-        var event = this.nativeEvent;
-        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
-        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
-    },
-    persist: function() {
-        this.isPersistent = emptyFunction.thatReturnsTrue;
-    },
-    isPersistent: emptyFunction.thatReturnsFalse,
-    destructor: function() {
-        var Interface = this.constructor.Interface;
-        for (var propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
-        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
-        Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null)), 
-        Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", emptyFunction)), 
-        Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", emptyFunction));
-    }
-}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
-    var Super = this, E = function() {};
-    E.prototype = Super.prototype;
-    var prototype = new E();
-    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
-    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
-    PooledClass_1.addPoolingTo(Class, PooledClass_1.fourArgumentPooler);
-}, isProxySupported && (SyntheticEvent = new Proxy(SyntheticEvent, {
-    construct: function(target, args) {
-        return this.apply(target, Object.create(target.prototype), args);
-    },
-    apply: function(constructor, that, args) {
-        return new Proxy(constructor.apply(that, args), {
-            set: function(target, prop, value) {
-                return "isPersistent" === prop || target.constructor.Interface.hasOwnProperty(prop) || -1 !== shouldBeReleasedProperties.indexOf(prop) || (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."), 
-                didWarnForAddedNewProperty = !0), target[prop] = value, !0;
-            }
-        });
-    }
-})), PooledClass_1.addPoolingTo(SyntheticEvent, PooledClass_1.fourArgumentPooler);
-
-var SyntheticEvent_1 = SyntheticEvent;
-
-function getPooledWarningPropertyDefinition(propName, getVal) {
-    var isFunction = "function" == typeof getVal;
-    return {
-        configurable: !0,
-        set: set,
-        get: get
-    };
-    function set(val) {
-        return warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op"), 
-        val;
-    }
-    function get() {
-        return warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null"), 
-        getVal;
-    }
-    function warn(action, result) {
-        warning(!1, "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);
-    }
-}
-
-var _extends = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
-
-for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
-
-for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
-allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
-
-var ReactNativeBridgeEventPlugin = {
-    eventTypes: _extends({}, customBubblingEventTypes, customDirectEventTypes),
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
-        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
-            if (!directDispatchConfig) return null;
-            EventPropagators_1.accumulateDirectDispatches(event);
-        }
-        return event;
-    }
-}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin, instanceCache = {}, instanceProps = {};
-
-function getRenderedHostOrTextFromComponent(component) {
-    for (var rendered; rendered = component._renderedComponent; ) component = rendered;
-    return component;
-}
-
-function precacheNode(inst, tag) {
-    var nativeInst = getRenderedHostOrTextFromComponent(inst);
-    instanceCache[tag] = nativeInst;
-}
-
-function precacheFiberNode(hostInst, tag) {
-    instanceCache[tag] = hostInst;
-}
-
-function uncacheNode(inst) {
-    var tag = inst._rootNodeID;
-    tag && delete instanceCache[tag];
-}
-
-function uncacheFiberNode(tag) {
-    delete instanceCache[tag], delete instanceProps[tag];
-}
-
-function getInstanceFromTag(tag) {
-    return instanceCache[tag] || null;
-}
-
-function getTagFromInstance(inst) {
-    var tag = "number" != typeof inst.tag ? inst._rootNodeID : inst.stateNode._nativeTag;
-    return invariant(tag, "All native instances should have a tag."), tag;
-}
-
-function getFiberCurrentPropsFromNode(stateNode) {
-    return instanceProps[stateNode._nativeTag] || null;
-}
-
-function updateFiberProps(tag, props) {
-    instanceProps[tag] = props;
-}
-
-var ReactNativeComponentTree = {
-    getClosestInstanceFromNode: getInstanceFromTag,
-    getInstanceFromNode: getInstanceFromTag,
-    getNodeFromInstance: getTagFromInstance,
-    precacheFiberNode: precacheFiberNode,
-    precacheNode: precacheNode,
-    uncacheFiberNode: uncacheFiberNode,
-    uncacheNode: uncacheNode,
-    getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
-    updateFiberProps: updateFiberProps
-}, ReactNativeComponentTree_1 = ReactNativeComponentTree;
-
-function runEventQueueInBatch(events) {
-    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
-}
-
-var ReactEventEmitterMixin = {
-    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
-    }
-}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
-    tagsStartAt: INITIAL_TAG_COUNT,
-    tagCount: INITIAL_TAG_COUNT,
-    allocateTag: function() {
-        for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
-        var tag = ReactNativeTagHandles.tagCount;
-        return ReactNativeTagHandles.tagCount++, tag;
-    },
-    assertRootTag: function(tag) {
-        invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
-    },
-    reactTagIsNativeTopRootID: function(reactTag) {
-        return reactTag % 10 == 1;
-    }
-}, ReactNativeTagHandles_1 = ReactNativeTagHandles, _extends$1 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
-    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
-    return ret;
-}, removeTouchesAtIndices = function(touches, indices) {
-    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
-        var index = indices[i];
-        rippedOut.push(touches[index]), temp[index] = null;
-    }
-    for (var fillAt = 0, j = 0; j < temp.length; j++) {
-        var cur = temp[j];
-        null !== cur && (temp[fillAt++] = cur);
-    }
-    return temp.length = fillAt, rippedOut;
-}, ReactNativeEventEmitter = _extends$1({}, ReactEventEmitterMixin_1, {
-    registrationNames: EventPluginRegistry_1.registrationNameModules,
-    getListener: EventPluginHub_1.getListener,
-    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
-        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
-        ReactGenericBatching_1.batchedUpdates(function() {
-            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
-        });
-    },
-    receiveEvent: function(tag, topLevelType, nativeEventParam) {
-        var rootNodeID = tag;
-        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
-    },
-    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
-        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
-            var touch = changedTouches[jj];
-            touch.changedTouches = changedTouches, touch.touches = touches;
-            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
-            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt ? warning(!1, "A view is reporting that a touch occurred on tag zero.") : rootNodeID = target), 
-            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+    function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+        if (event && event.dispatchConfig.phasedRegistrationNames) {
+            var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
+            ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
         }
     }
-}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
-    onChange: function(from, to, blockNativeResponder) {
-        if (null !== to) {
-            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
-            UIManager.setJSResponder(tag, blockNativeResponder);
-        } else UIManager.clearJSResponder();
-    }
-}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
-    touchHistory: function(nativeEvent) {
-        return null;
-    }
-};
-
-function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-}
-
-SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
-
-var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
-    touchBank: touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0
-};
-
-function timestampForTouch(touch) {
-    return touch.timeStamp || touch.timestamp;
-}
-
-function createTouchRecord(touch) {
-    return {
-        touchActive: !0,
-        startPageX: touch.pageX,
-        startPageY: touch.pageY,
-        startTimeStamp: timestampForTouch(touch),
-        currentPageX: touch.pageX,
-        currentPageY: touch.pageY,
-        currentTimeStamp: timestampForTouch(touch),
-        previousPageX: touch.pageX,
-        previousPageY: touch.pageY,
-        previousTimeStamp: timestampForTouch(touch)
-    };
-}
-
-function resetTouchRecord(touchRecord, touch) {
-    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
-    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
-    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
-    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
-    touchRecord.previousTimeStamp = timestampForTouch(touch);
-}
-
-function getTouchIdentifier(_ref) {
-    var identifier = _ref.identifier;
-    return invariant(null != identifier, "Touch object is missing identifier."), warning(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
-    identifier;
-}
-
-function recordTouchStart(touch) {
-    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
-    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
-    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-}
-
-function recordTouchMove(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function recordTouchEnd(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function printTouch(touch) {
-    return JSON.stringify({
-        identifier: touch.identifier,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        timestamp: timestampForTouch(touch)
-    });
-}
-
-function printTouchBank() {
-    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
-    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
-    printed;
-}
-
-var ResponderTouchHistoryStore = {
-    recordTouchTrack: function(topLevelType, nativeEvent) {
-        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) {
-            for (var i = 0; i < touchBank.length; i++) {
-                var touchTrackToCheck = touchBank[i];
-                if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
-                    touchHistory.indexOfSingleActiveTouch = i;
-                    break;
-                }
-            }
-            var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
-            warning(null != activeRecord && activeRecord.touchActive, "Cannot find single active touch.");
-        }
-    },
-    touchHistory: touchHistory
-}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
-
-function accumulate(current, next) {
-    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
-    var oldResponderInst = responderInst;
-    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
-}, eventTypes = {
-    startShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onStartShouldSetResponder",
-            captured: "onStartShouldSetResponderCapture"
-        }
-    },
-    scrollShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onScrollShouldSetResponder",
-            captured: "onScrollShouldSetResponderCapture"
-        }
-    },
-    selectionChangeShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onSelectionChangeShouldSetResponder",
-            captured: "onSelectionChangeShouldSetResponderCapture"
-        }
-    },
-    moveShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onMoveShouldSetResponder",
-            captured: "onMoveShouldSetResponderCapture"
-        }
-    },
-    responderStart: {
-        registrationName: "onResponderStart"
-    },
-    responderMove: {
-        registrationName: "onResponderMove"
-    },
-    responderEnd: {
-        registrationName: "onResponderEnd"
-    },
-    responderRelease: {
-        registrationName: "onResponderRelease"
-    },
-    responderTerminationRequest: {
-        registrationName: "onResponderTerminationRequest"
-    },
-    responderGrant: {
-        registrationName: "onResponderGrant"
-    },
-    responderReject: {
-        registrationName: "onResponderReject"
-    },
-    responderTerminate: {
-        registrationName: "onResponderTerminate"
-    }
-};
-
-function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
-    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
-    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
-    !wantsResponderInst || wantsResponderInst === responderInst) return null;
-    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
-    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
-    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
-    if (responderInst) {
-        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
-        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
-        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
-        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
-        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
-        shouldSwitch) {
-            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
-            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
-            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
-        } else {
-            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
-            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
-            extracted = accumulate_1(extracted, rejectEvent);
-        }
-    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
-    return extracted;
-}
-
-function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
-    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
-}
-
-function noResponderTouches(nativeEvent) {
-    var touches = nativeEvent.touches;
-    if (!touches || 0 === touches.length) return !0;
-    for (var i = 0; i < touches.length; i++) {
-        var activeTouch = touches[i], target = activeTouch.target;
-        if (null !== target && void 0 !== target && 0 !== target) {
-            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
-            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
+    function accumulateDispatches(inst, ignoredDirection, event) {
+        if (inst && event && event.dispatchConfig.registrationName) {
+            var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+            listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+            event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
         }
     }
-    return !0;
-}
-
-var ResponderEventPlugin = {
-    _getResponder: function() {
-        return responderInst;
-    },
-    eventTypes: eventTypes,
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
-            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
-            null;
-            trackedTouchCount -= 1;
-        }
-        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
-        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
-        if (incrementalTouch) {
-            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
-            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
-            extracted = accumulate_1(extracted, gesture);
-        }
-        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
-        if (finalTouch) {
-            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
-            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
-            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
-        }
-        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
-        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
-        previousActiveTouches = numberActiveTouches, extracted;
-    },
-    GlobalResponderHandler: null,
-    GlobalInteractionHandler: null,
-    injection: {
-        injectGlobalResponderHandler: function(GlobalResponderHandler) {
-            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+    function accumulateDirectDispatchesSingle(event) {
+        event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
+    }
+    function accumulateTwoPhaseDispatches(events) {
+        forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
+    }
+    function accumulateTwoPhaseDispatchesSkipTarget(events) {
+        forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+    }
+    function accumulateEnterLeaveDispatches(leave, enter, from, to) {
+        ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
+    }
+    function accumulateDirectDispatches(events) {
+        forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
+    }
+    var EventPropagators = {
+        accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
+        accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
+        accumulateDirectDispatches: accumulateDirectDispatches,
+        accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
+    }, EventPropagators_1 = EventPropagators, didWarnForAddedNewProperty = !1, isProxySupported = "function" == typeof Proxy, EVENT_POOL_SIZE = 10, warning$12 = require$$0, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
+        type: null,
+        target: null,
+        currentTarget: emptyFunction.thatReturnsNull,
+        eventPhase: null,
+        bubbles: null,
+        cancelable: null,
+        timeStamp: function(event) {
+            return event.timeStamp || Date.now();
         },
-        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
-            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+        defaultPrevented: null,
+        isTrusted: null
+    };
+    function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+        delete this.nativeEvent, delete this.preventDefault, delete this.stopPropagation, 
+        this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
+        var Interface = this.constructor.Interface;
+        for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
+            delete this[propName];
+            var normalize = Interface[propName];
+            normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
+        }
+        var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
+        return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
+        this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
+    }
+    Object.assign(SyntheticEvent.prototype, {
+        preventDefault: function() {
+            this.defaultPrevented = !0;
+            var event = this.nativeEvent;
+            event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
+            this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
+        },
+        stopPropagation: function() {
+            var event = this.nativeEvent;
+            event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
+            this.isPropagationStopped = emptyFunction.thatReturnsTrue);
+        },
+        persist: function() {
+            this.isPersistent = emptyFunction.thatReturnsTrue;
+        },
+        isPersistent: emptyFunction.thatReturnsFalse,
+        destructor: function() {
+            var Interface = this.constructor.Interface;
+            for (var propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+            for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
+            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null)), 
+            Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", emptyFunction)), 
+            Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", emptyFunction));
+        }
+    }), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
+        var Super = this, E = function() {};
+        E.prototype = Super.prototype;
+        var prototype = new E();
+        Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
+        Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
+        addEventPoolingTo(Class);
+    }, isProxySupported && (SyntheticEvent = new Proxy(SyntheticEvent, {
+        construct: function(target, args) {
+            return this.apply(target, Object.create(target.prototype), args);
+        },
+        apply: function(constructor, that, args) {
+            return new Proxy(constructor.apply(that, args), {
+                set: function(target, prop, value) {
+                    return "isPersistent" === prop || target.constructor.Interface.hasOwnProperty(prop) || -1 !== shouldBeReleasedProperties.indexOf(prop) || (warning$12(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."), 
+                    didWarnForAddedNewProperty = !0), target[prop] = value, !0;
+                }
+            });
+        }
+    })), addEventPoolingTo(SyntheticEvent);
+    var SyntheticEvent_1 = SyntheticEvent;
+    function getPooledWarningPropertyDefinition(propName, getVal) {
+        var isFunction = "function" == typeof getVal;
+        return {
+            configurable: !0,
+            set: set,
+            get: get
+        };
+        function set(val) {
+            return warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op"), 
+            val;
+        }
+        function get() {
+            return warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null"), 
+            getVal;
+        }
+        function warn(action, result) {
+            warning$12(!1, "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);
         }
     }
-}, ResponderEventPlugin_1 = ResponderEventPlugin;
-
-function inject() {
+    function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+        var EventConstructor = this;
+        if (EventConstructor.eventPool.length) {
+            var instance = EventConstructor.eventPool.pop();
+            return EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst), 
+            instance;
+        }
+        return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+    }
+    function releasePooledEvent(event) {
+        var EventConstructor = this;
+        invariant(event instanceof EventConstructor, "Trying to release an event instance  into a pool of a different type."), 
+        event.destructor(), EventConstructor.eventPool.length < EVENT_POOL_SIZE && EventConstructor.eventPool.push(event);
+    }
+    function addEventPoolingTo(EventConstructor) {
+        EventConstructor.eventPool = [], EventConstructor.getPooled = getPooledEvent, EventConstructor.release = releasePooledEvent;
+    }
+    var customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
+    for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
+    for (var directTypeName in customDirectEventTypes) require$$0(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
+    allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
+    var ReactNativeBridgeEventPlugin = {
+        eventTypes: Object.assign({}, customBubblingEventTypes, customDirectEventTypes),
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+            if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
+                if (!directDispatchConfig) return null;
+                EventPropagators_1.accumulateDirectDispatches(event);
+            }
+            return event;
+        }
+    }, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
+    function runEventQueueInBatch(events) {
+        EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
+    }
+    var ReactEventEmitterMixin = {
+        handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
+        }
+    }, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
+        for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
+        return ret;
+    }, removeTouchesAtIndices = function(touches, indices) {
+        for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
+            var index = indices[i];
+            rippedOut.push(touches[index]), temp[index] = null;
+        }
+        for (var fillAt = 0, j = 0; j < temp.length; j++) {
+            var cur = temp[j];
+            null !== cur && (temp[fillAt++] = cur);
+        }
+        return temp.length = fillAt, rippedOut;
+    }, ReactNativeEventEmitter = Object.assign({}, ReactEventEmitterMixin_1, {
+        registrationNames: EventPluginRegistry_1.registrationNameModules,
+        getListener: EventPluginHub_1.getListener,
+        _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
+            var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
+            ReactGenericBatching_1.batchedUpdates(function() {
+                ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
+            });
+        },
+        receiveEvent: function(tag, topLevelType, nativeEventParam) {
+            var rootNodeID = tag;
+            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+        },
+        receiveTouches: function(eventTopLevelType, touches, changedIndices) {
+            for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
+                var touch = changedTouches[jj];
+                touch.changedTouches = changedTouches, touch.touches = touches;
+                var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
+                null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt ? require$$0(!1, "A view is reporting that a touch occurred on tag zero.") : rootNodeID = target), 
+                ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+            }
+        }
+    }), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
+        onChange: function(from, to, blockNativeResponder) {
+            if (null !== to) {
+                var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
+                UIManager.setJSResponder(tag, blockNativeResponder);
+            } else UIManager.clearJSResponder();
+        }
+    }, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
+        touchHistory: function(nativeEvent) {
+            return null;
+        }
+    };
+    function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+        return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+    }
+    SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
+    var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, warning$13 = require$$0, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
+        touchBank: touchBank,
+        numberActiveTouches: 0,
+        indexOfSingleActiveTouch: -1,
+        mostRecentTimeStamp: 0
+    };
+    function timestampForTouch(touch) {
+        return touch.timeStamp || touch.timestamp;
+    }
+    function createTouchRecord(touch) {
+        return {
+            touchActive: !0,
+            startPageX: touch.pageX,
+            startPageY: touch.pageY,
+            startTimeStamp: timestampForTouch(touch),
+            currentPageX: touch.pageX,
+            currentPageY: touch.pageY,
+            currentTimeStamp: timestampForTouch(touch),
+            previousPageX: touch.pageX,
+            previousPageY: touch.pageY,
+            previousTimeStamp: timestampForTouch(touch)
+        };
+    }
+    function resetTouchRecord(touchRecord, touch) {
+        touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
+        touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
+        touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
+        touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
+        touchRecord.previousTimeStamp = timestampForTouch(touch);
+    }
+    function getTouchIdentifier(_ref) {
+        var identifier = _ref.identifier;
+        return invariant(null != identifier, "Touch object is missing identifier."), warning$13(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
+        identifier;
+    }
+    function recordTouchStart(touch) {
+        var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
+        touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
+        touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+    }
+    function recordTouchMove(touch) {
+        var touchRecord = touchBank[getTouchIdentifier(touch)];
+        touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
+        touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+        touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+        touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function recordTouchEnd(touch) {
+        var touchRecord = touchBank[getTouchIdentifier(touch)];
+        touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
+        touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+        touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+        touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function printTouch(touch) {
+        return JSON.stringify({
+            identifier: touch.identifier,
+            pageX: touch.pageX,
+            pageY: touch.pageY,
+            timestamp: timestampForTouch(touch)
+        });
+    }
+    function printTouchBank() {
+        var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+        return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
+        printed;
+    }
+    var ResponderTouchHistoryStore = {
+        recordTouchTrack: function(topLevelType, nativeEvent) {
+            if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
+            touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
+            touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) {
+                for (var i = 0; i < touchBank.length; i++) {
+                    var touchTrackToCheck = touchBank[i];
+                    if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
+                        touchHistory.indexOfSingleActiveTouch = i;
+                        break;
+                    }
+                }
+                var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+                warning$13(null != activeRecord && activeRecord.touchActive, "Cannot find single active touch.");
+            }
+        },
+        touchHistory: touchHistory
+    }, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
+    function accumulate(current, next) {
+        return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
+        null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+    }
+    var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
+        var oldResponderInst = responderInst;
+        responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+    }, eventTypes = {
+        startShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onStartShouldSetResponder",
+                captured: "onStartShouldSetResponderCapture"
+            }
+        },
+        scrollShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onScrollShouldSetResponder",
+                captured: "onScrollShouldSetResponderCapture"
+            }
+        },
+        selectionChangeShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onSelectionChangeShouldSetResponder",
+                captured: "onSelectionChangeShouldSetResponderCapture"
+            }
+        },
+        moveShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onMoveShouldSetResponder",
+                captured: "onMoveShouldSetResponderCapture"
+            }
+        },
+        responderStart: {
+            registrationName: "onResponderStart"
+        },
+        responderMove: {
+            registrationName: "onResponderMove"
+        },
+        responderEnd: {
+            registrationName: "onResponderEnd"
+        },
+        responderRelease: {
+            registrationName: "onResponderRelease"
+        },
+        responderTerminationRequest: {
+            registrationName: "onResponderTerminationRequest"
+        },
+        responderGrant: {
+            registrationName: "onResponderGrant"
+        },
+        responderReject: {
+            registrationName: "onResponderReject"
+        },
+        responderTerminate: {
+            registrationName: "onResponderTerminate"
+        }
+    };
+    function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
+        shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
+        var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
+        if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
+        !wantsResponderInst || wantsResponderInst === responderInst) return null;
+        var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
+        grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
+        var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
+        if (responderInst) {
+            var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
+            terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
+            EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
+            var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
+            if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
+            shouldSwitch) {
+                var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
+                extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
+            } else {
+                var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
+                rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
+                extracted = accumulate_1(extracted, rejectEvent);
+            }
+        } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
+        return extracted;
+    }
+    function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
+        return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
+    }
+    function noResponderTouches(nativeEvent) {
+        var touches = nativeEvent.touches;
+        if (!touches || 0 === touches.length) return !0;
+        for (var i = 0; i < touches.length; i++) {
+            var activeTouch = touches[i], target = activeTouch.target;
+            if (null !== target && void 0 !== target && 0 !== target) {
+                var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
+                if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
+            }
+        }
+        return !0;
+    }
+    var ResponderEventPlugin = {
+        _getResponder: function() {
+            return responderInst;
+        },
+        eventTypes: eventTypes,
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
+                if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
+                null;
+                trackedTouchCount -= 1;
+            }
+            ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
+            var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
+            if (incrementalTouch) {
+                var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
+                gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
+                extracted = accumulate_1(extracted, gesture);
+            }
+            var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
+            if (finalTouch) {
+                var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
+                finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
+                extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
+            }
+            var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
+            return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
+            previousActiveTouches = numberActiveTouches, extracted;
+        },
+        GlobalResponderHandler: null,
+        GlobalInteractionHandler: null,
+        injection: {
+            injectGlobalResponderHandler: function(GlobalResponderHandler) {
+                ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+            },
+            injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
+                ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+            }
+        }
+    }, ResponderEventPlugin_1 = ResponderEventPlugin;
     RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
     EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
     EventPluginHub_1.injection.injectEventPluginsByName({
         ResponderEventPlugin: ResponderEventPlugin_1,
         ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
     });
-}
-
-var ReactNativeInjection = {
-    inject: inject
-}, REACT_PORTAL_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.portal") || 60106, createPortal = function(children, containerInfo, implementation) {
-    var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null;
-    return {
-        $$typeof: REACT_PORTAL_TYPE,
-        key: null == key ? null : "" + key,
-        children: children,
-        containerInfo: containerInfo,
-        implementation: implementation
-    };
-}, isPortal = function(object) {
-    return "object" == typeof object && null !== object && object.$$typeof === REACT_PORTAL_TYPE;
-}, REACT_PORTAL_TYPE_1 = REACT_PORTAL_TYPE, ReactPortal = {
-    createPortal: createPortal,
-    isPortal: isPortal,
-    REACT_PORTAL_TYPE: REACT_PORTAL_TYPE_1
-}, commonjsGlobal = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {}, ReactFeatureFlags = {
-    disableNewFiberFeatures: !1,
-    enableAsyncSubtreeAPI: !1
-}, ReactFeatureFlags_1 = ReactFeatureFlags, ReactTypeOfSideEffect = {
-    NoEffect: 0,
-    PerformedWork: 1,
-    Placement: 2,
-    Update: 4,
-    PlacementAndUpdate: 6,
-    Deletion: 8,
-    ContentReset: 16,
-    Callback: 32,
-    Err: 64,
-    Ref: 128
-}, ReactPriorityLevel = {
-    NoWork: 0,
-    SynchronousPriority: 1,
-    TaskPriority: 2,
-    HighPriority: 3,
-    LowPriority: 4,
-    OffscreenPriority: 5
-}, CallbackEffect = ReactTypeOfSideEffect.Callback, NoWork = ReactPriorityLevel.NoWork, SynchronousPriority = ReactPriorityLevel.SynchronousPriority, TaskPriority = ReactPriorityLevel.TaskPriority, ClassComponent = ReactTypeOfWork.ClassComponent, HostRoot = ReactTypeOfWork.HostRoot, warning$3 = warning;
-
-function comparePriority(a, b) {
-    return a !== TaskPriority && a !== SynchronousPriority || b !== TaskPriority && b !== SynchronousPriority ? a === NoWork && b !== NoWork ? -255 : a !== NoWork && b === NoWork ? 255 : a - b : 0;
-}
-
-function createUpdateQueue() {
-    var queue = {
-        first: null,
-        last: null,
-        hasForceUpdate: !1,
-        callbackList: null
-    };
-    return queue.isProcessing = !1, queue;
-}
-
-function cloneUpdate(update) {
-    return {
-        priorityLevel: update.priorityLevel,
-        partialState: update.partialState,
-        callback: update.callback,
-        isReplace: update.isReplace,
-        isForced: update.isForced,
-        isTopLevelUnmount: update.isTopLevelUnmount,
-        next: null
-    };
-}
-
-function insertUpdateIntoQueue(queue, update, insertAfter, insertBefore) {
-    null !== insertAfter ? insertAfter.next = update : (update.next = queue.first, queue.first = update), 
-    null !== insertBefore ? update.next = insertBefore : queue.last = update;
-}
-
-function findInsertionPosition(queue, update) {
-    var priorityLevel = update.priorityLevel, insertAfter = null, insertBefore = null;
-    if (null !== queue.last && comparePriority(queue.last.priorityLevel, priorityLevel) <= 0) insertAfter = queue.last; else for (insertBefore = queue.first; null !== insertBefore && comparePriority(insertBefore.priorityLevel, priorityLevel) <= 0; ) insertAfter = insertBefore, 
-    insertBefore = insertBefore.next;
-    return insertAfter;
-}
-
-function ensureUpdateQueues(fiber) {
-    var alternateFiber = fiber.alternate, queue1 = fiber.updateQueue;
-    null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue());
-    var queue2 = void 0;
-    return null !== alternateFiber ? null === (queue2 = alternateFiber.updateQueue) && (queue2 = alternateFiber.updateQueue = createUpdateQueue()) : queue2 = null, 
-    [ queue1, queue2 !== queue1 ? queue2 : null ];
-}
-
-function insertUpdate(fiber, update) {
-    var _ensureUpdateQueues = ensureUpdateQueues(fiber), queue1 = _ensureUpdateQueues[0], queue2 = _ensureUpdateQueues[1];
-    (queue1.isProcessing || null !== queue2 && queue2.isProcessing) && warning$3(!1, "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.");
-    var insertAfter1 = findInsertionPosition(queue1, update), insertBefore1 = null !== insertAfter1 ? insertAfter1.next : queue1.first;
-    if (null === queue2) return insertUpdateIntoQueue(queue1, update, insertAfter1, insertBefore1), 
-    null;
-    var insertAfter2 = findInsertionPosition(queue2, update), insertBefore2 = null !== insertAfter2 ? insertAfter2.next : queue2.first;
-    if (insertUpdateIntoQueue(queue1, update, insertAfter1, insertBefore1), insertBefore1 === insertBefore2 && null !== insertBefore1 || insertAfter1 === insertAfter2 && null !== insertAfter1) return null === insertAfter2 && (queue2.first = update), 
-    null === insertBefore2 && (queue2.last = null), null;
-    var update2 = cloneUpdate(update);
-    return insertUpdateIntoQueue(queue2, update2, insertAfter2, insertBefore2), update2;
-}
-
-function addUpdate(fiber, partialState, callback, priorityLevel) {
-    insertUpdate(fiber, {
-        priorityLevel: priorityLevel,
-        partialState: partialState,
-        callback: callback,
-        isReplace: !1,
-        isForced: !1,
-        isTopLevelUnmount: !1,
-        next: null
-    });
-}
-
-var addUpdate_1 = addUpdate;
-
-function addReplaceUpdate(fiber, state, callback, priorityLevel) {
-    insertUpdate(fiber, {
-        priorityLevel: priorityLevel,
-        partialState: state,
-        callback: callback,
-        isReplace: !0,
-        isForced: !1,
-        isTopLevelUnmount: !1,
-        next: null
-    });
-}
-
-var addReplaceUpdate_1 = addReplaceUpdate;
-
-function addForceUpdate(fiber, callback, priorityLevel) {
-    insertUpdate(fiber, {
-        priorityLevel: priorityLevel,
-        partialState: null,
-        callback: callback,
-        isReplace: !1,
-        isForced: !0,
-        isTopLevelUnmount: !1,
-        next: null
-    });
-}
-
-var addForceUpdate_1 = addForceUpdate;
-
-function getUpdatePriority(fiber) {
-    var updateQueue = fiber.updateQueue;
-    return null === updateQueue ? NoWork : fiber.tag !== ClassComponent && fiber.tag !== HostRoot ? NoWork : null !== updateQueue.first ? updateQueue.first.priorityLevel : NoWork;
-}
-
-var getUpdatePriority_1 = getUpdatePriority;
-
-function addTopLevelUpdate$1(fiber, partialState, callback, priorityLevel) {
-    var isTopLevelUnmount = null === partialState.element, update = {
-        priorityLevel: priorityLevel,
-        partialState: partialState,
-        callback: callback,
-        isReplace: !1,
-        isForced: !1,
-        isTopLevelUnmount: isTopLevelUnmount,
-        next: null
-    }, update2 = insertUpdate(fiber, update);
-    if (isTopLevelUnmount) {
-        var _ensureUpdateQueues2 = ensureUpdateQueues(fiber), queue1 = _ensureUpdateQueues2[0], queue2 = _ensureUpdateQueues2[1];
-        null !== queue1 && null !== update.next && (update.next = null, queue1.last = update), 
-        null !== queue2 && null !== update2 && null !== update2.next && (update2.next = null, 
-        queue2.last = update);
+    var DevOnlyStubShim = null;
+    function _classCallCheck$2(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
     }
-}
-
-var addTopLevelUpdate_1 = addTopLevelUpdate$1;
-
-function getStateFromUpdate(update, instance, prevState, props) {
-    var partialState = update.partialState;
-    if ("function" == typeof partialState) {
-        return partialState.call(instance, prevState, props);
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
     }
-    return partialState;
-}
-
-function beginUpdateQueue(current, workInProgress, queue, instance, prevState, props, priorityLevel) {
-    if (null !== current && current.updateQueue === queue) {
-        var currentQueue = queue;
-        queue = workInProgress.updateQueue = {
-            first: currentQueue.first,
-            last: currentQueue.last,
-            callbackList: null,
-            hasForceUpdate: !1
-        };
-    }
-    queue.isProcessing = !0;
-    for (var callbackList = queue.callbackList, hasForceUpdate = queue.hasForceUpdate, state = prevState, dontMutatePrevState = !0, update = queue.first; null !== update && comparePriority(update.priorityLevel, priorityLevel) <= 0; ) {
-        queue.first = update.next, null === queue.first && (queue.last = null);
-        var _partialState = void 0;
-        update.isReplace ? (state = getStateFromUpdate(update, instance, state, props), 
-        dontMutatePrevState = !0) : (_partialState = getStateFromUpdate(update, instance, state, props)) && (state = dontMutatePrevState ? Object.assign({}, state, _partialState) : Object.assign(state, _partialState), 
-        dontMutatePrevState = !1), update.isForced && (hasForceUpdate = !0), null === update.callback || update.isTopLevelUnmount && null !== update.next || (callbackList = null !== callbackList ? callbackList : [], 
-        callbackList.push(update.callback), workInProgress.effectTag |= CallbackEffect), 
-        update = update.next;
-    }
-    return queue.callbackList = callbackList, queue.hasForceUpdate = hasForceUpdate, 
-    null !== queue.first || null !== callbackList || hasForceUpdate || (workInProgress.updateQueue = null), 
-    queue.isProcessing = !1, state;
-}
-
-var beginUpdateQueue_1 = beginUpdateQueue;
-
-function commitCallbacks(finishedWork, queue, context) {
-    var callbackList = queue.callbackList;
-    if (null !== callbackList) {
-        queue.callbackList = null;
-        for (var i = 0; i < callbackList.length; i++) {
-            var _callback = callbackList[i];
-            invariant("function" == typeof _callback, "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", _callback), 
-            _callback.call(context);
-        }
-    }
-}
-
-var commitCallbacks_1 = commitCallbacks, ReactFiberUpdateQueue = {
-    addUpdate: addUpdate_1,
-    addReplaceUpdate: addReplaceUpdate_1,
-    addForceUpdate: addForceUpdate_1,
-    getUpdatePriority: getUpdatePriority_1,
-    addTopLevelUpdate: addTopLevelUpdate_1,
-    beginUpdateQueue: beginUpdateQueue_1,
-    commitCallbacks: commitCallbacks_1
-};
-
-function getComponentName$1(instanceOrFiber) {
-    if ("function" == typeof instanceOrFiber.getName) {
-        return instanceOrFiber.getName();
-    }
-    if ("number" == typeof instanceOrFiber.tag) {
-        var fiber = instanceOrFiber, type = fiber.type;
-        if ("string" == typeof type) return type;
-        if ("function" == typeof type) return type.displayName || type.name;
-    }
-    return null;
-}
-
-var getComponentName_1 = getComponentName$1, ReactInstanceMap = {
-    remove: function(key) {
-        key._reactInternalInstance = void 0;
-    },
-    get: function(key) {
-        return key._reactInternalInstance;
-    },
-    has: function(key) {
-        return void 0 !== key._reactInternalInstance;
-    },
-    set: function(key, value) {
-        key._reactInternalInstance = value;
-    }
-}, ReactInstanceMap_1 = ReactInstanceMap, ReactInternals = react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, ReactGlobalSharedState = {
-    ReactCurrentOwner: ReactInternals.ReactCurrentOwner
-};
-
-Object.assign(ReactGlobalSharedState, {
-    ReactComponentTreeHook: ReactInternals.ReactComponentTreeHook,
-    ReactDebugCurrentFrame: ReactInternals.ReactDebugCurrentFrame
-});
-
-var ReactGlobalSharedState_1 = ReactGlobalSharedState, ReactCurrentOwner = ReactGlobalSharedState_1.ReactCurrentOwner, warning$4 = warning, HostRoot$2 = ReactTypeOfWork.HostRoot, HostComponent$2 = ReactTypeOfWork.HostComponent, HostText = ReactTypeOfWork.HostText, ClassComponent$2 = ReactTypeOfWork.ClassComponent, NoEffect = ReactTypeOfSideEffect.NoEffect, Placement = ReactTypeOfSideEffect.Placement, MOUNTING = 1, MOUNTED = 2, UNMOUNTED = 3;
-
-function isFiberMountedImpl(fiber) {
-    var node = fiber;
-    if (fiber.alternate) for (;node.return; ) node = node.return; else {
-        if ((node.effectTag & Placement) !== NoEffect) return MOUNTING;
-        for (;node.return; ) if (node = node.return, (node.effectTag & Placement) !== NoEffect) return MOUNTING;
-    }
-    return node.tag === HostRoot$2 ? MOUNTED : UNMOUNTED;
-}
-
-var isFiberMounted$1 = function(fiber) {
-    return isFiberMountedImpl(fiber) === MOUNTED;
-}, isMounted = function(component) {
-    var owner = ReactCurrentOwner.current;
-    if (null !== owner && owner.tag === ClassComponent$2) {
-        var ownerFiber = owner, instance = ownerFiber.stateNode;
-        warning$4(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_1(ownerFiber) || "A component"), 
-        instance._warnedAboutRefsInRender = !0;
-    }
-    var fiber = ReactInstanceMap_1.get(component);
-    return !!fiber && isFiberMountedImpl(fiber) === MOUNTED;
-};
-
-function assertIsMounted(fiber) {
-    invariant(isFiberMountedImpl(fiber) === MOUNTED, "Unable to find node on an unmounted component.");
-}
-
-function findCurrentFiberUsingSlowPath(fiber) {
-    var alternate = fiber.alternate;
-    if (!alternate) {
-        var state = isFiberMountedImpl(fiber);
-        return invariant(state !== UNMOUNTED, "Unable to find node on an unmounted component."), 
-        state === MOUNTING ? null : fiber;
-    }
-    for (var a = fiber, b = alternate; !0; ) {
-        var parentA = a.return, parentB = parentA ? parentA.alternate : null;
-        if (!parentA || !parentB) break;
-        if (parentA.child === parentB.child) {
-            for (var child = parentA.child; child; ) {
-                if (child === a) return assertIsMounted(parentA), fiber;
-                if (child === b) return assertIsMounted(parentA), alternate;
-                child = child.sibling;
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
             }
-            invariant(!1, "Unable to find node on an unmounted component.");
-        }
-        if (a.return !== b.return) a = parentA, b = parentB; else {
-            for (var didFindChild = !1, _child = parentA.child; _child; ) {
-                if (_child === a) {
-                    didFindChild = !0, a = parentA, b = parentB;
-                    break;
-                }
-                if (_child === b) {
-                    didFindChild = !0, b = parentA, a = parentB;
-                    break;
-                }
-                _child = _child.sibling;
-            }
-            if (!didFindChild) {
-                for (_child = parentB.child; _child; ) {
-                    if (_child === a) {
-                        didFindChild = !0, a = parentB, b = parentA;
-                        break;
-                    }
-                    if (_child === b) {
-                        didFindChild = !0, b = parentB, a = parentA;
-                        break;
-                    }
-                    _child = _child.sibling;
-                }
-                invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "related to the return pointer.");
-            }
-        }
-        invariant(a.alternate === b, "Return fibers should always be each others' alternates.");
-    }
-    return invariant(a.tag === HostRoot$2, "Unable to find node on an unmounted component."), 
-    a.stateNode.current === a ? fiber : alternate;
-}
-
-var findCurrentFiberUsingSlowPath_1 = findCurrentFiberUsingSlowPath, findCurrentHostFiber$1 = function(parent) {
-    var currentParent = findCurrentFiberUsingSlowPath(parent);
-    if (!currentParent) return null;
-    for (var node = currentParent; !0; ) {
-        if (node.tag === HostComponent$2 || node.tag === HostText) return node;
-        if (node.child) node.child.return = node, node = node.child; else {
-            if (node === currentParent) return null;
-            for (;!node.sibling; ) {
-                if (!node.return || node.return === currentParent) return null;
-                node = node.return;
-            }
-            node.sibling.return = node.return, node = node.sibling;
-        }
-    }
-    return null;
-}, ReactFiberTreeReflection = {
-    isFiberMounted: isFiberMounted$1,
-    isMounted: isMounted,
-    findCurrentFiberUsingSlowPath: findCurrentFiberUsingSlowPath_1,
-    findCurrentHostFiber: findCurrentHostFiber$1
-}, valueStack = [], fiberStack = [], index = -1, createCursor$1 = function(defaultValue) {
-    return {
-        current: defaultValue
-    };
-}, isEmpty = function() {
-    return -1 === index;
-}, pop$1 = function(cursor, fiber) {
-    if (index < 0) return void warning(!1, "Unexpected pop.");
-    fiber !== fiberStack[index] && warning(!1, "Unexpected Fiber popped."), cursor.current = valueStack[index], 
-    valueStack[index] = null, fiberStack[index] = null, index--;
-}, push$1 = function(cursor, value, fiber) {
-    index++, valueStack[index] = cursor.current, fiberStack[index] = fiber, cursor.current = value;
-}, reset = function() {
-    for (;index > -1; ) valueStack[index] = null, fiberStack[index] = null, index--;
-}, ReactFiberStack = {
-    createCursor: createCursor$1,
-    isEmpty: isEmpty,
-    pop: pop$1,
-    push: push$1,
-    reset: reset
-}, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent = ReactTypeOfWork.FunctionalComponent, ClassComponent$3 = ReactTypeOfWork.ClassComponent, HostComponent$3 = ReactTypeOfWork.HostComponent;
-
-function describeComponentFrame(name, source, ownerName) {
-    return "\n    in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
-}
-
-function describeFiber(fiber) {
-    switch (fiber.tag) {
-      case IndeterminateComponent:
-      case FunctionalComponent:
-      case ClassComponent$3:
-      case HostComponent$3:
-        var owner = fiber._debugOwner, source = fiber._debugSource, name = getComponentName_1(fiber), ownerName = null;
-        return owner && (ownerName = getComponentName_1(owner)), describeComponentFrame(name, source, ownerName);
-
-      default:
-        return "";
-    }
-}
-
-function getStackAddendumByWorkInProgressFiber$1(workInProgress) {
-    var info = "", node = workInProgress;
-    do {
-        info += describeFiber(node), node = node.return;
-    } while (node);
-    return info;
-}
-
-var ReactFiberComponentTreeHook = {
-    getStackAddendumByWorkInProgressFiber: getStackAddendumByWorkInProgressFiber$1,
-    describeComponentFrame: describeComponentFrame
-}, getComponentName$3 = getComponentName_1, _require$1 = ReactFiberComponentTreeHook, getStackAddendumByWorkInProgressFiber = _require$1.getStackAddendumByWorkInProgressFiber;
-
-function getCurrentFiberOwnerName() {
-    var fiber = ReactDebugCurrentFiber$2.current;
-    return null === fiber ? null : null != fiber._debugOwner ? getComponentName$3(fiber._debugOwner) : null;
-}
-
-function getCurrentFiberStackAddendum() {
-    var fiber = ReactDebugCurrentFiber$2.current;
-    return null === fiber ? null : getStackAddendumByWorkInProgressFiber(fiber);
-}
-
-var ReactDebugCurrentFiber$2 = {
-    current: null,
-    phase: null,
-    getCurrentFiberOwnerName: getCurrentFiberOwnerName,
-    getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
-}, ReactDebugCurrentFiber_1 = ReactDebugCurrentFiber$2, ReactDebugFiberPerf = null, _require$2 = ReactTypeOfWork, HostRoot$3 = _require$2.HostRoot, HostComponent$4 = _require$2.HostComponent, HostText$1 = _require$2.HostText, HostPortal = _require$2.HostPortal, YieldComponent = _require$2.YieldComponent, Fragment = _require$2.Fragment, getComponentName$4 = getComponentName_1, reactEmoji = "⚛", warningEmoji = "⛔", supportsUserTiming = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, currentFiber = null, currentPhase = null, currentPhaseFiber = null, isCommitting = !1, hasScheduledUpdateInCurrentCommit = !1, hasScheduledUpdateInCurrentPhase = !1, commitCountInCurrentWorkLoop = 0, effectCountInCurrentCommit = 0, labelsInCurrentCommit = new Set(), formatMarkName = function(markName) {
-    return reactEmoji + " " + markName;
-}, formatLabel = function(label, warning$$1) {
-    return (warning$$1 ? warningEmoji + " " : reactEmoji + " ") + label + (warning$$1 ? " Warning: " + warning$$1 : "");
-}, beginMark = function(markName) {
-    performance.mark(formatMarkName(markName));
-}, clearMark = function(markName) {
-    performance.clearMarks(formatMarkName(markName));
-}, endMark = function(label, markName, warning$$1) {
-    var formattedMarkName = formatMarkName(markName), formattedLabel = formatLabel(label, warning$$1);
-    try {
-        performance.measure(formattedLabel, formattedMarkName);
-    } catch (err) {}
-    performance.clearMarks(formattedMarkName), performance.clearMeasures(formattedLabel);
-}, getFiberMarkName = function(label, debugID) {
-    return label + " (#" + debugID + ")";
-}, getFiberLabel = function(componentName, isMounted, phase) {
-    return null === phase ? componentName + " [" + (isMounted ? "update" : "mount") + "]" : componentName + "." + phase;
-}, beginFiberMark = function(fiber, phase) {
-    var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase);
-    if (isCommitting && labelsInCurrentCommit.has(label)) return !1;
-    labelsInCurrentCommit.add(label);
-    var markName = getFiberMarkName(label, debugID);
-    return beginMark(markName), !0;
-}, clearFiberMark = function(fiber, phase) {
-    var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase), markName = getFiberMarkName(label, debugID);
-    clearMark(markName);
-}, endFiberMark = function(fiber, phase, warning$$1) {
-    var componentName = getComponentName$4(fiber) || "Unknown", debugID = fiber._debugID, isMounted = null !== fiber.alternate, label = getFiberLabel(componentName, isMounted, phase), markName = getFiberMarkName(label, debugID);
-    endMark(label, markName, warning$$1);
-}, shouldIgnoreFiber = function(fiber) {
-    switch (fiber.tag) {
-      case HostRoot$3:
-      case HostComponent$4:
-      case HostText$1:
-      case HostPortal:
-      case YieldComponent:
-      case Fragment:
-        return !0;
-
-      default:
-        return !1;
-    }
-}, clearPendingPhaseMeasurement = function() {
-    null !== currentPhase && null !== currentPhaseFiber && clearFiberMark(currentPhaseFiber, currentPhase), 
-    currentPhaseFiber = null, currentPhase = null, hasScheduledUpdateInCurrentPhase = !1;
-}, pauseTimers = function() {
-    for (var fiber = currentFiber; fiber; ) fiber._debugIsCurrentlyTiming && endFiberMark(fiber, null, null), 
-    fiber = fiber.return;
-}, resumeTimersRecursively = function(fiber) {
-    null !== fiber.return && resumeTimersRecursively(fiber.return), fiber._debugIsCurrentlyTiming && beginFiberMark(fiber, null);
-}, resumeTimers = function() {
-    null !== currentFiber && resumeTimersRecursively(currentFiber);
-};
-
-ReactDebugFiberPerf = {
-    recordEffect: function() {
-        effectCountInCurrentCommit++;
-    },
-    recordScheduleUpdate: function() {
-        isCommitting && (hasScheduledUpdateInCurrentCommit = !0), null !== currentPhase && "componentWillMount" !== currentPhase && "componentWillReceiveProps" !== currentPhase && (hasScheduledUpdateInCurrentPhase = !0);
-    },
-    startWorkTimer: function(fiber) {
-        supportsUserTiming && !shouldIgnoreFiber(fiber) && (currentFiber = fiber, beginFiberMark(fiber, null) && (fiber._debugIsCurrentlyTiming = !0));
-    },
-    cancelWorkTimer: function(fiber) {
-        supportsUserTiming && !shouldIgnoreFiber(fiber) && (fiber._debugIsCurrentlyTiming = !1, 
-        clearFiberMark(fiber, null));
-    },
-    stopWorkTimer: function(fiber) {
-        supportsUserTiming && !shouldIgnoreFiber(fiber) && (currentFiber = fiber.return, 
-        fiber._debugIsCurrentlyTiming && (fiber._debugIsCurrentlyTiming = !1, endFiberMark(fiber, null, null)));
-    },
-    startPhaseTimer: function(fiber, phase) {
-        supportsUserTiming && (clearPendingPhaseMeasurement(), beginFiberMark(fiber, phase) && (currentPhaseFiber = fiber, 
-        currentPhase = phase));
-    },
-    stopPhaseTimer: function() {
-        if (supportsUserTiming) {
-            if (null !== currentPhase && null !== currentPhaseFiber) {
-                endFiberMark(currentPhaseFiber, currentPhase, hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null);
-            }
-            currentPhase = null, currentPhaseFiber = null;
-        }
-    },
-    startWorkLoopTimer: function() {
-        supportsUserTiming && (commitCountInCurrentWorkLoop = 0, beginMark("(React Tree Reconciliation)"), 
-        resumeTimers());
-    },
-    stopWorkLoopTimer: function() {
-        if (supportsUserTiming) {
-            var warning$$1 = commitCountInCurrentWorkLoop > 1 ? "There were cascading updates" : null;
-            commitCountInCurrentWorkLoop = 0, pauseTimers(), endMark("(React Tree Reconciliation)", "(React Tree Reconciliation)", warning$$1);
-        }
-    },
-    startCommitTimer: function() {
-        supportsUserTiming && (isCommitting = !0, hasScheduledUpdateInCurrentCommit = !1, 
-        labelsInCurrentCommit.clear(), beginMark("(Committing Changes)"));
-    },
-    stopCommitTimer: function() {
-        if (supportsUserTiming) {
-            var warning$$1 = null;
-            hasScheduledUpdateInCurrentCommit ? warning$$1 = "Lifecycle hook scheduled a cascading update" : commitCountInCurrentWorkLoop > 0 && (warning$$1 = "Caused by a cascading update in earlier commit"), 
-            hasScheduledUpdateInCurrentCommit = !1, commitCountInCurrentWorkLoop++, isCommitting = !1, 
-            labelsInCurrentCommit.clear(), endMark("(Committing Changes)", "(Committing Changes)", warning$$1);
-        }
-    },
-    startCommitHostEffectsTimer: function() {
-        supportsUserTiming && (effectCountInCurrentCommit = 0, beginMark("(Committing Host Effects)"));
-    },
-    stopCommitHostEffectsTimer: function() {
-        if (supportsUserTiming) {
-            var count = effectCountInCurrentCommit;
-            effectCountInCurrentCommit = 0, endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
-        }
-    },
-    startCommitLifeCyclesTimer: function() {
-        supportsUserTiming && (effectCountInCurrentCommit = 0, beginMark("(Calling Lifecycle Methods)"));
-    },
-    stopCommitLifeCyclesTimer: function() {
-        if (supportsUserTiming) {
-            var count = effectCountInCurrentCommit;
-            effectCountInCurrentCommit = 0, endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
-        }
-    }
-};
-
-var ReactDebugFiberPerf_1 = ReactDebugFiberPerf, _extends$2 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, isFiberMounted = ReactFiberTreeReflection.isFiberMounted, ClassComponent$1 = ReactTypeOfWork.ClassComponent, HostRoot$1 = ReactTypeOfWork.HostRoot, createCursor = ReactFiberStack.createCursor, pop = ReactFiberStack.pop, push = ReactFiberStack.push, ReactDebugCurrentFiber$1 = ReactDebugCurrentFiber_1, _require4 = ReactGlobalSharedState_1, ReactDebugCurrentFrame = _require4.ReactDebugCurrentFrame, _require5 = ReactDebugFiberPerf_1, startPhaseTimer = _require5.startPhaseTimer, stopPhaseTimer = _require5.stopPhaseTimer, warnedAboutMissingGetChildContext = {}, contextStackCursor = createCursor(emptyObject), didPerformWorkStackCursor = createCursor(!1), previousContext = emptyObject;
-
-function getUnmaskedContext(workInProgress) {
-    return isContextProvider$1(workInProgress) ? previousContext : contextStackCursor.current;
-}
-
-var getUnmaskedContext_1 = getUnmaskedContext;
-
-function cacheContext(workInProgress, unmaskedContext, maskedContext) {
-    var instance = workInProgress.stateNode;
-    instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
-}
-
-var cacheContext_1 = cacheContext, getMaskedContext = function(workInProgress, unmaskedContext) {
-    var type = workInProgress.type, contextTypes = type.contextTypes;
-    if (!contextTypes) return emptyObject;
-    var instance = workInProgress.stateNode;
-    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
-    var context = {};
-    for (var key in contextTypes) context[key] = unmaskedContext[key];
-    var name = getComponentName_1(workInProgress) || "Unknown";
-    return ReactDebugCurrentFrame.current = workInProgress, checkPropTypes(contextTypes, context, "context", name, ReactDebugCurrentFrame.getStackAddendum), 
-    ReactDebugCurrentFrame.current = null, instance && cacheContext(workInProgress, unmaskedContext, context), 
-    context;
-}, hasContextChanged = function() {
-    return didPerformWorkStackCursor.current;
-};
-
-function isContextConsumer(fiber) {
-    return fiber.tag === ClassComponent$1 && null != fiber.type.contextTypes;
-}
-
-var isContextConsumer_1 = isContextConsumer;
-
-function isContextProvider$1(fiber) {
-    return fiber.tag === ClassComponent$1 && null != fiber.type.childContextTypes;
-}
-
-var isContextProvider_1 = isContextProvider$1;
-
-function popContextProvider(fiber) {
-    isContextProvider$1(fiber) && (pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber));
-}
-
-var popContextProvider_1 = popContextProvider, pushTopLevelContextObject = function(fiber, context, didChange) {
-    invariant(null == contextStackCursor.cursor, "Unexpected context found on stack"), 
-    push(contextStackCursor, context, fiber), push(didPerformWorkStackCursor, didChange, fiber);
-};
-
-function processChildContext$1(fiber, parentContext, isReconciling) {
-    var instance = fiber.stateNode, childContextTypes = fiber.type.childContextTypes;
-    if ("function" != typeof instance.getChildContext) {
-        var componentName = getComponentName_1(fiber) || "Unknown";
-        return warnedAboutMissingGetChildContext[componentName] || (warnedAboutMissingGetChildContext[componentName] = !0, 
-        warning(!1, "%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)), 
-        parentContext;
-    }
-    var childContext = void 0;
-    ReactDebugCurrentFiber$1.phase = "getChildContext", startPhaseTimer(fiber, "getChildContext"), 
-    childContext = instance.getChildContext(), stopPhaseTimer(), ReactDebugCurrentFiber$1.phase = null;
-    for (var contextKey in childContext) invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName_1(fiber) || "Unknown", contextKey);
-    var name = getComponentName_1(fiber) || "Unknown", workInProgress = isReconciling ? fiber : null;
-    return ReactDebugCurrentFrame.current = workInProgress, checkPropTypes(childContextTypes, childContext, "child context", name, ReactDebugCurrentFrame.getStackAddendum), 
-    ReactDebugCurrentFrame.current = null, _extends$2({}, parentContext, childContext);
-}
-
-var processChildContext_1 = processChildContext$1, pushContextProvider = function(workInProgress) {
-    if (!isContextProvider$1(workInProgress)) return !1;
-    var instance = workInProgress.stateNode, memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
-    return previousContext = contextStackCursor.current, push(contextStackCursor, memoizedMergedChildContext, workInProgress), 
-    push(didPerformWorkStackCursor, !1, workInProgress), !0;
-}, invalidateContextProvider = function(workInProgress) {
-    var instance = workInProgress.stateNode;
-    invariant(instance, "Expected to have an instance by this point.");
-    var mergedContext = processChildContext$1(workInProgress, previousContext, !0);
-    instance.__reactInternalMemoizedMergedChildContext = mergedContext, pop(didPerformWorkStackCursor, workInProgress), 
-    pop(contextStackCursor, workInProgress), push(contextStackCursor, mergedContext, workInProgress), 
-    push(didPerformWorkStackCursor, !0, workInProgress);
-}, resetContext = function() {
-    previousContext = emptyObject, contextStackCursor.current = emptyObject, didPerformWorkStackCursor.current = !1;
-}, findCurrentUnmaskedContext$1 = function(fiber) {
-    invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent$1, "Expected subtree parent to be a mounted class component");
-    for (var node = fiber; node.tag !== HostRoot$1; ) {
-        if (isContextProvider$1(node)) return node.stateNode.__reactInternalMemoizedMergedChildContext;
-        var parent = node.return;
-        invariant(parent, "Found unexpected detached subtree parent"), node = parent;
-    }
-    return node.stateNode.context;
-}, ReactFiberContext = {
-    getUnmaskedContext: getUnmaskedContext_1,
-    cacheContext: cacheContext_1,
-    getMaskedContext: getMaskedContext,
-    hasContextChanged: hasContextChanged,
-    isContextConsumer: isContextConsumer_1,
-    isContextProvider: isContextProvider_1,
-    popContextProvider: popContextProvider_1,
-    pushTopLevelContextObject: pushTopLevelContextObject,
-    processChildContext: processChildContext_1,
-    pushContextProvider: pushContextProvider,
-    invalidateContextProvider: invalidateContextProvider,
-    resetContext: resetContext,
-    findCurrentUnmaskedContext: findCurrentUnmaskedContext$1
-}, ReactTypeOfInternalContext = {
-    NoContext: 0,
-    AsyncUpdates: 1
-}, IndeterminateComponent$1 = ReactTypeOfWork.IndeterminateComponent, ClassComponent$4 = ReactTypeOfWork.ClassComponent, HostRoot$4 = ReactTypeOfWork.HostRoot, HostComponent$5 = ReactTypeOfWork.HostComponent, HostText$2 = ReactTypeOfWork.HostText, HostPortal$1 = ReactTypeOfWork.HostPortal, CoroutineComponent = ReactTypeOfWork.CoroutineComponent, YieldComponent$1 = ReactTypeOfWork.YieldComponent, Fragment$1 = ReactTypeOfWork.Fragment, NoWork$1 = ReactPriorityLevel.NoWork, NoContext = ReactTypeOfInternalContext.NoContext, NoEffect$1 = ReactTypeOfSideEffect.NoEffect, getComponentName$5 = getComponentName_1, hasBadMapPolyfill = !1;
-
-try {
-    var nonExtensibleObject = Object.preventExtensions({});
-    new Map([ [ nonExtensibleObject, null ] ]), new Set([ nonExtensibleObject ]);
-} catch (e) {
-    hasBadMapPolyfill = !0;
-}
-
-var debugCounter = 1, createFiber = function(tag, key, internalContextTag) {
-    var fiber = {
-        tag: tag,
-        key: key,
-        type: null,
-        stateNode: null,
-        return: null,
-        child: null,
-        sibling: null,
-        index: 0,
-        ref: null,
-        pendingProps: null,
-        memoizedProps: null,
-        updateQueue: null,
-        memoizedState: null,
-        internalContextTag: internalContextTag,
-        effectTag: NoEffect$1,
-        nextEffect: null,
-        firstEffect: null,
-        lastEffect: null,
-        pendingWorkPriority: NoWork$1,
-        alternate: null
-    };
-    return fiber._debugID = debugCounter++, fiber._debugSource = null, fiber._debugOwner = null, 
-    fiber._debugIsCurrentlyTiming = !1, hasBadMapPolyfill || "function" != typeof Object.preventExtensions || Object.preventExtensions(fiber), 
-    fiber;
-};
-
-function shouldConstruct(Component) {
-    return !(!Component.prototype || !Component.prototype.isReactComponent);
-}
-
-var createWorkInProgress = function(current, renderPriority) {
-    var workInProgress = current.alternate;
-    return null === workInProgress ? (workInProgress = createFiber(current.tag, current.key, current.internalContextTag), 
-    workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, 
-    workInProgress._debugID = current._debugID, workInProgress._debugSource = current._debugSource, 
-    workInProgress._debugOwner = current._debugOwner, workInProgress.alternate = current, 
-    current.alternate = workInProgress) : (workInProgress.effectTag = NoWork$1, workInProgress.nextEffect = null, 
-    workInProgress.firstEffect = null, workInProgress.lastEffect = null), workInProgress.pendingWorkPriority = renderPriority, 
-    workInProgress.child = current.child, workInProgress.memoizedProps = current.memoizedProps, 
-    workInProgress.memoizedState = current.memoizedState, workInProgress.updateQueue = current.updateQueue, 
-    workInProgress.sibling = current.sibling, workInProgress.index = current.index, 
-    workInProgress.ref = current.ref, workInProgress;
-}, createHostRootFiber$1 = function() {
-    return createFiber(HostRoot$4, null, NoContext);
-}, createFiberFromElement = function(element, internalContextTag, priorityLevel) {
-    var owner = null;
-    owner = element._owner;
-    var fiber = createFiberFromElementType(element.type, element.key, internalContextTag, owner);
-    return fiber.pendingProps = element.props, fiber.pendingWorkPriority = priorityLevel, 
-    fiber._debugSource = element._source, fiber._debugOwner = element._owner, fiber;
-}, createFiberFromFragment = function(elements, internalContextTag, priorityLevel) {
-    var fiber = createFiber(Fragment$1, null, internalContextTag);
-    return fiber.pendingProps = elements, fiber.pendingWorkPriority = priorityLevel, 
-    fiber;
-}, createFiberFromText = function(content, internalContextTag, priorityLevel) {
-    var fiber = createFiber(HostText$2, null, internalContextTag);
-    return fiber.pendingProps = content, fiber.pendingWorkPriority = priorityLevel, 
-    fiber;
-};
-
-function createFiberFromElementType(type, key, internalContextTag, debugOwner) {
-    var fiber = void 0;
-    if ("function" == typeof type) fiber = shouldConstruct(type) ? createFiber(ClassComponent$4, key, internalContextTag) : createFiber(IndeterminateComponent$1, key, internalContextTag), 
-    fiber.type = type; else if ("string" == typeof type) fiber = createFiber(HostComponent$5, key, internalContextTag), 
-    fiber.type = type; else if ("object" == typeof type && null !== type && "number" == typeof type.tag) fiber = type; else {
-        var info = "";
-        (void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file " + "it's defined in.");
-        var ownerName = debugOwner ? getComponentName$5(debugOwner) : null;
-        ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`."), invariant(!1, "Element type is invalid: expected a string (for built-in components) " + "or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info);
-    }
-    return fiber;
-}
-
-var createFiberFromElementType_1 = createFiberFromElementType, createFiberFromHostInstanceForDeletion = function() {
-    var fiber = createFiber(HostComponent$5, null, NoContext);
-    return fiber.type = "DELETED", fiber;
-}, createFiberFromCoroutine = function(coroutine, internalContextTag, priorityLevel) {
-    var fiber = createFiber(CoroutineComponent, coroutine.key, internalContextTag);
-    return fiber.type = coroutine.handler, fiber.pendingProps = coroutine, fiber.pendingWorkPriority = priorityLevel, 
-    fiber;
-}, createFiberFromYield = function(yieldNode, internalContextTag, priorityLevel) {
-    return createFiber(YieldComponent$1, null, internalContextTag);
-}, createFiberFromPortal = function(portal, internalContextTag, priorityLevel) {
-    var fiber = createFiber(HostPortal$1, portal.key, internalContextTag);
-    return fiber.pendingProps = portal.children || [], fiber.pendingWorkPriority = priorityLevel, 
-    fiber.stateNode = {
-        containerInfo: portal.containerInfo,
-        implementation: portal.implementation
-    }, fiber;
-}, largerPriority = function(p1, p2) {
-    return p1 !== NoWork$1 && (p2 === NoWork$1 || p2 > p1) ? p1 : p2;
-}, ReactFiber = {
-    createWorkInProgress: createWorkInProgress,
-    createHostRootFiber: createHostRootFiber$1,
-    createFiberFromElement: createFiberFromElement,
-    createFiberFromFragment: createFiberFromFragment,
-    createFiberFromText: createFiberFromText,
-    createFiberFromElementType: createFiberFromElementType_1,
-    createFiberFromHostInstanceForDeletion: createFiberFromHostInstanceForDeletion,
-    createFiberFromCoroutine: createFiberFromCoroutine,
-    createFiberFromYield: createFiberFromYield,
-    createFiberFromPortal: createFiberFromPortal,
-    largerPriority: largerPriority
-}, createHostRootFiber = ReactFiber.createHostRootFiber, createFiberRoot$1 = function(containerInfo) {
-    var uninitializedFiber = createHostRootFiber(), root = {
-        current: uninitializedFiber,
-        containerInfo: containerInfo,
-        isScheduled: !1,
-        nextScheduledRoot: null,
-        context: null,
-        pendingContext: null
-    };
-    return uninitializedFiber.stateNode = root, root;
-}, ReactFiberRoot = {
-    createFiberRoot: createFiberRoot$1
-}, REACT_COROUTINE_TYPE$1, REACT_YIELD_TYPE$1;
-
-"function" == typeof Symbol && Symbol.for ? (REACT_COROUTINE_TYPE$1 = Symbol.for("react.coroutine"), 
-REACT_YIELD_TYPE$1 = Symbol.for("react.yield")) : (REACT_COROUTINE_TYPE$1 = 60104, 
-REACT_YIELD_TYPE$1 = 60105);
-
-var createCoroutine = function(children, handler, props) {
-    var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null, coroutine = {
-        $$typeof: REACT_COROUTINE_TYPE$1,
-        key: null == key ? null : "" + key,
-        children: children,
-        handler: handler,
-        props: props
-    };
-    return Object.freeze && (Object.freeze(coroutine.props), Object.freeze(coroutine)), 
-    coroutine;
-}, createYield = function(value) {
-    var yieldNode = {
-        $$typeof: REACT_YIELD_TYPE$1,
-        value: value
-    };
-    return Object.freeze && Object.freeze(yieldNode), yieldNode;
-}, isCoroutine = function(object) {
-    return "object" == typeof object && null !== object && object.$$typeof === REACT_COROUTINE_TYPE$1;
-}, isYield = function(object) {
-    return "object" == typeof object && null !== object && object.$$typeof === REACT_YIELD_TYPE$1;
-}, REACT_YIELD_TYPE_1 = REACT_YIELD_TYPE$1, REACT_COROUTINE_TYPE_1 = REACT_COROUTINE_TYPE$1, ReactCoroutine = {
-    createCoroutine: createCoroutine,
-    createYield: createYield,
-    isCoroutine: isCoroutine,
-    isYield: isYield,
-    REACT_YIELD_TYPE: REACT_YIELD_TYPE_1,
-    REACT_COROUTINE_TYPE: REACT_COROUTINE_TYPE_1
-}, REACT_COROUTINE_TYPE = ReactCoroutine.REACT_COROUTINE_TYPE, REACT_YIELD_TYPE = ReactCoroutine.REACT_YIELD_TYPE, REACT_PORTAL_TYPE$1 = ReactPortal.REACT_PORTAL_TYPE, _require3$3 = ReactDebugCurrentFiber_1, getCurrentFiberStackAddendum$1 = _require3$3.getCurrentFiberStackAddendum, warning$7 = warning, didWarnAboutMaps = !1, ownerHasKeyUseWarning = {}, warnForMissingKey = function(child) {
-    if (null !== child && "object" == typeof child && child._store && !child._store.validated && null == child.key) {
-        invariant("object" == typeof child._store, "React Component in warnForMissingKey should have a _store"), 
-        child._store.validated = !0;
-        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() || "");
-        ownerHasKeyUseWarning[currentComponentErrorInfo] || (ownerHasKeyUseWarning[currentComponentErrorInfo] = !0, 
-        warning$7(!1, "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()));
-    }
-}, createWorkInProgress$2 = ReactFiber.createWorkInProgress, createFiberFromElement$1 = ReactFiber.createFiberFromElement, createFiberFromFragment$1 = ReactFiber.createFiberFromFragment, createFiberFromText$1 = ReactFiber.createFiberFromText, createFiberFromCoroutine$1 = ReactFiber.createFiberFromCoroutine, createFiberFromYield$1 = ReactFiber.createFiberFromYield, createFiberFromPortal$1 = ReactFiber.createFiberFromPortal, isArray = Array.isArray, FunctionalComponent$2 = ReactTypeOfWork.FunctionalComponent, ClassComponent$7 = ReactTypeOfWork.ClassComponent, HostText$4 = ReactTypeOfWork.HostText, HostPortal$4 = ReactTypeOfWork.HostPortal, CoroutineComponent$2 = ReactTypeOfWork.CoroutineComponent, YieldComponent$3 = ReactTypeOfWork.YieldComponent, Fragment$3 = ReactTypeOfWork.Fragment, NoEffect$2 = ReactTypeOfSideEffect.NoEffect, Placement$3 = ReactTypeOfSideEffect.Placement, Deletion$1 = ReactTypeOfSideEffect.Deletion, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103;
-
-function getIteratorFn(maybeIterable) {
-    if (null === maybeIterable || void 0 === maybeIterable) return null;
-    var iteratorFn = ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
-    return "function" == typeof iteratorFn ? iteratorFn : null;
-}
-
-function coerceRef(current, element) {
-    var mixedRef = element.ref;
-    if (null !== mixedRef && "function" != typeof mixedRef && element._owner) {
-        var owner = element._owner, inst = void 0;
-        if (owner) if ("number" == typeof owner.tag) {
-            var ownerFiber = owner;
-            invariant(ownerFiber.tag === ClassComponent$7, "Stateless function components cannot have refs."), 
-            inst = ownerFiber.stateNode;
-        } else inst = owner.getPublicInstance();
-        invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
-        var stringRef = "" + mixedRef;
-        if (null !== current && null !== current.ref && current.ref._stringRef === stringRef) return current.ref;
-        var ref = function(value) {
-            var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
-            null === value ? delete refs[stringRef] : refs[stringRef] = value;
-        };
-        return ref._stringRef = stringRef, ref;
-    }
-    return mixedRef;
-}
-
-function throwOnInvalidObjectType(returnFiber, newChild) {
-    if ("textarea" !== returnFiber.type) {
-        var addendum = "";
-        addendum = " If you meant to render a collection of children, use an array " + "instead." + (getCurrentFiberStackAddendum$1() || ""), 
-        invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[object Object]" === Object.prototype.toString.call(newChild) ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild, addendum);
-    }
-}
-
-function ChildReconciler(shouldClone, shouldTrackSideEffects) {
-    function deleteChild(returnFiber, childToDelete) {
-        if (shouldTrackSideEffects) {
-            if (!shouldClone) {
-                if (null === childToDelete.alternate) return;
-                childToDelete = childToDelete.alternate;
-            }
-            var last = returnFiber.lastEffect;
-            null !== last ? (last.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete, 
-            childToDelete.nextEffect = null, childToDelete.effectTag = Deletion$1;
-        }
-    }
-    function deleteRemainingChildren(returnFiber, currentFirstChild) {
-        if (!shouldTrackSideEffects) return null;
-        for (var childToDelete = currentFirstChild; null !== childToDelete; ) deleteChild(returnFiber, childToDelete), 
-        childToDelete = childToDelete.sibling;
-        return null;
-    }
-    function mapRemainingChildren(returnFiber, currentFirstChild) {
-        for (var existingChildren = new Map(), existingChild = currentFirstChild; null !== existingChild; ) null !== existingChild.key ? existingChildren.set(existingChild.key, existingChild) : existingChildren.set(existingChild.index, existingChild), 
-        existingChild = existingChild.sibling;
-        return existingChildren;
-    }
-    function useFiber(fiber, priority) {
-        if (shouldClone) {
-            var clone = createWorkInProgress$2(fiber, priority);
-            return clone.index = 0, clone.sibling = null, clone;
-        }
-        return fiber.pendingWorkPriority = priority, fiber.effectTag = NoEffect$2, fiber.index = 0, 
-        fiber.sibling = null, fiber;
-    }
-    function placeChild(newFiber, lastPlacedIndex, newIndex) {
-        if (newFiber.index = newIndex, !shouldTrackSideEffects) return lastPlacedIndex;
-        var current = newFiber.alternate;
-        if (null !== current) {
-            var oldIndex = current.index;
-            return oldIndex < lastPlacedIndex ? (newFiber.effectTag = Placement$3, lastPlacedIndex) : oldIndex;
-        }
-        return newFiber.effectTag = Placement$3, lastPlacedIndex;
-    }
-    function placeSingleChild(newFiber) {
-        return shouldTrackSideEffects && null === newFiber.alternate && (newFiber.effectTag = Placement$3), 
-        newFiber;
-    }
-    function updateTextNode(returnFiber, current, textContent, priority) {
-        if (null === current || current.tag !== HostText$4) {
-            var created = createFiberFromText$1(textContent, returnFiber.internalContextTag, priority);
-            return created.return = returnFiber, created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.pendingProps = textContent, existing.return = returnFiber, existing;
-    }
-    function updateElement(returnFiber, current, element, priority) {
-        if (null === current || current.type !== element.type) {
-            var created = createFiberFromElement$1(element, returnFiber.internalContextTag, priority);
-            return created.ref = coerceRef(current, element), created.return = returnFiber, 
-            created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.ref = coerceRef(current, element), existing.pendingProps = element.props, 
-        existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, 
-        existing;
-    }
-    function updateCoroutine(returnFiber, current, coroutine, priority) {
-        if (null === current || current.tag !== CoroutineComponent$2) {
-            var created = createFiberFromCoroutine$1(coroutine, returnFiber.internalContextTag, priority);
-            return created.return = returnFiber, created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.pendingProps = coroutine, existing.return = returnFiber, existing;
-    }
-    function updateYield(returnFiber, current, yieldNode, priority) {
-        if (null === current || current.tag !== YieldComponent$3) {
-            var created = createFiberFromYield$1(yieldNode, returnFiber.internalContextTag, priority);
-            return created.type = yieldNode.value, created.return = returnFiber, created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.type = yieldNode.value, existing.return = returnFiber, existing;
-    }
-    function updatePortal(returnFiber, current, portal, priority) {
-        if (null === current || current.tag !== HostPortal$4 || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
-            var created = createFiberFromPortal$1(portal, returnFiber.internalContextTag, priority);
-            return created.return = returnFiber, created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.pendingProps = portal.children || [], existing.return = returnFiber, 
-        existing;
-    }
-    function updateFragment(returnFiber, current, fragment, priority) {
-        if (null === current || current.tag !== Fragment$3) {
-            var created = createFiberFromFragment$1(fragment, returnFiber.internalContextTag, priority);
-            return created.return = returnFiber, created;
-        }
-        var existing = useFiber(current, priority);
-        return existing.pendingProps = fragment, existing.return = returnFiber, existing;
-    }
-    function createChild(returnFiber, newChild, priority) {
-        if ("string" == typeof newChild || "number" == typeof newChild) {
-            var created = createFiberFromText$1("" + newChild, returnFiber.internalContextTag, priority);
-            return created.return = returnFiber, created;
-        }
-        if ("object" == typeof newChild && null !== newChild) {
-            switch (newChild.$$typeof) {
-              case REACT_ELEMENT_TYPE:
-                var _created = createFiberFromElement$1(newChild, returnFiber.internalContextTag, priority);
-                return _created.ref = coerceRef(null, newChild), _created.return = returnFiber, 
-                _created;
-
-              case REACT_COROUTINE_TYPE:
-                var _created2 = createFiberFromCoroutine$1(newChild, returnFiber.internalContextTag, priority);
-                return _created2.return = returnFiber, _created2;
-
-              case REACT_YIELD_TYPE:
-                var _created3 = createFiberFromYield$1(newChild, returnFiber.internalContextTag, priority);
-                return _created3.type = newChild.value, _created3.return = returnFiber, _created3;
-
-              case REACT_PORTAL_TYPE$1:
-                var _created4 = createFiberFromPortal$1(newChild, returnFiber.internalContextTag, priority);
-                return _created4.return = returnFiber, _created4;
-            }
-            if (isArray(newChild) || getIteratorFn(newChild)) {
-                var _created5 = createFiberFromFragment$1(newChild, returnFiber.internalContextTag, priority);
-                return _created5.return = returnFiber, _created5;
-            }
-            throwOnInvalidObjectType(returnFiber, newChild);
-        }
-        return null;
-    }
-    function updateSlot(returnFiber, oldFiber, newChild, priority) {
-        var key = null !== oldFiber ? oldFiber.key : null;
-        if ("string" == typeof newChild || "number" == typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, priority);
-        if ("object" == typeof newChild && null !== newChild) {
-            switch (newChild.$$typeof) {
-              case REACT_ELEMENT_TYPE:
-                return newChild.key === key ? updateElement(returnFiber, oldFiber, newChild, priority) : null;
-
-              case REACT_COROUTINE_TYPE:
-                return newChild.key === key ? updateCoroutine(returnFiber, oldFiber, newChild, priority) : null;
-
-              case REACT_YIELD_TYPE:
-                return null === key ? updateYield(returnFiber, oldFiber, newChild, priority) : null;
-
-              case REACT_PORTAL_TYPE$1:
-                return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, priority) : null;
-            }
-            if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, priority);
-            throwOnInvalidObjectType(returnFiber, newChild);
-        }
-        return null;
-    }
-    function updateFromMap(existingChildren, returnFiber, newIdx, newChild, priority) {
-        if ("string" == typeof newChild || "number" == typeof newChild) {
-            return updateTextNode(returnFiber, existingChildren.get(newIdx) || null, "" + newChild, priority);
-        }
-        if ("object" == typeof newChild && null !== newChild) {
-            switch (newChild.$$typeof) {
-              case REACT_ELEMENT_TYPE:
-                return updateElement(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
-
-              case REACT_COROUTINE_TYPE:
-                return updateCoroutine(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
-
-              case REACT_YIELD_TYPE:
-                return updateYield(returnFiber, existingChildren.get(newIdx) || null, newChild, priority);
-
-              case REACT_PORTAL_TYPE$1:
-                return updatePortal(returnFiber, existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild, priority);
-            }
-            if (isArray(newChild) || getIteratorFn(newChild)) {
-                return updateFragment(returnFiber, existingChildren.get(newIdx) || null, newChild, priority);
-            }
-            throwOnInvalidObjectType(returnFiber, newChild);
-        }
-        return null;
-    }
-    function warnOnInvalidKey(child, knownKeys) {
-        if ("object" != typeof child || null === child) return knownKeys;
-        switch (child.$$typeof) {
-          case REACT_ELEMENT_TYPE:
-          case REACT_COROUTINE_TYPE:
-          case REACT_PORTAL_TYPE$1:
-            warnForMissingKey(child);
-            var key = child.key;
-            if ("string" != typeof key) break;
-            if (null === knownKeys) {
-                knownKeys = new Set(), knownKeys.add(key);
-                break;
-            }
-            if (!knownKeys.has(key)) {
-                knownKeys.add(key);
-                break;
-            }
-            warning$7(!1, "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());
-        }
-        return knownKeys;
-    }
-    function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, priority) {
-        for (var knownKeys = null, i = 0; i < newChildren.length; i++) {
-            knownKeys = warnOnInvalidKey(newChildren[i], knownKeys);
-        }
-        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
-            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
-            var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], priority);
-            if (null === newFiber) {
-                null === oldFiber && (oldFiber = nextOldFiber);
-                break;
-            }
-            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber), 
-            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber, 
-            previousNewFiber = newFiber, oldFiber = nextOldFiber;
-        }
-        if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), 
-        resultingFirstChild;
-        if (null === oldFiber) {
-            for (;newIdx < newChildren.length; newIdx++) {
-                var _newFiber = createChild(returnFiber, newChildren[newIdx], priority);
-                _newFiber && (lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx), 
-                null === previousNewFiber ? resultingFirstChild = _newFiber : previousNewFiber.sibling = _newFiber, 
-                previousNewFiber = _newFiber);
-            }
-            return resultingFirstChild;
-        }
-        for (var existingChildren = mapRemainingChildren(returnFiber, oldFiber); newIdx < newChildren.length; newIdx++) {
-            var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], priority);
-            _newFiber2 && (shouldTrackSideEffects && null !== _newFiber2.alternate && existingChildren.delete(null === _newFiber2.key ? newIdx : _newFiber2.key), 
-            lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber2 : previousNewFiber.sibling = _newFiber2, 
-            previousNewFiber = _newFiber2);
-        }
-        return shouldTrackSideEffects && existingChildren.forEach(function(child) {
-            return deleteChild(returnFiber, child);
-        }), resultingFirstChild;
-    }
-    function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, priority) {
-        var iteratorFn = getIteratorFn(newChildrenIterable);
-        if (invariant("function" == typeof iteratorFn, "An object is not an iterable. This error is likely caused by a bug in " + "React. Please file an issue."), 
-        "function" == typeof newChildrenIterable.entries) {
-            newChildrenIterable.entries === iteratorFn && (warning$7(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()), 
-            didWarnAboutMaps = !0);
-        }
-        var _newChildren = iteratorFn.call(newChildrenIterable);
-        if (_newChildren) for (var knownKeys = null, _step = _newChildren.next(); !_step.done; _step = _newChildren.next()) {
-            var child = _step.value;
-            knownKeys = warnOnInvalidKey(child, knownKeys);
-        }
-        var newChildren = iteratorFn.call(newChildrenIterable);
-        invariant(null != newChildren, "An iterable object provided no iterator.");
-        for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, lastPlacedIndex = 0, newIdx = 0, nextOldFiber = null, step = newChildren.next(); null !== oldFiber && !step.done; newIdx++, 
-        step = newChildren.next()) {
-            oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
-            var newFiber = updateSlot(returnFiber, oldFiber, step.value, priority);
-            if (null === newFiber) {
-                oldFiber || (oldFiber = nextOldFiber);
-                break;
-            }
-            shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber), 
-            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber, 
-            previousNewFiber = newFiber, oldFiber = nextOldFiber;
-        }
-        if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;
-        if (null === oldFiber) {
-            for (;!step.done; newIdx++, step = newChildren.next()) {
-                var _newFiber3 = createChild(returnFiber, step.value, priority);
-                null !== _newFiber3 && (lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx), 
-                null === previousNewFiber ? resultingFirstChild = _newFiber3 : previousNewFiber.sibling = _newFiber3, 
-                previousNewFiber = _newFiber3);
-            }
-            return resultingFirstChild;
-        }
-        for (var existingChildren = mapRemainingChildren(returnFiber, oldFiber); !step.done; newIdx++, 
-        step = newChildren.next()) {
-            var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, priority);
-            null !== _newFiber4 && (shouldTrackSideEffects && null !== _newFiber4.alternate && existingChildren.delete(null === _newFiber4.key ? newIdx : _newFiber4.key), 
-            lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx), null === previousNewFiber ? resultingFirstChild = _newFiber4 : previousNewFiber.sibling = _newFiber4, 
-            previousNewFiber = _newFiber4);
-        }
-        return shouldTrackSideEffects && existingChildren.forEach(function(child) {
-            return deleteChild(returnFiber, child);
-        }), resultingFirstChild;
-    }
-    function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, priority) {
-        if (null !== currentFirstChild && currentFirstChild.tag === HostText$4) {
-            deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
-            var existing = useFiber(currentFirstChild, priority);
-            return existing.pendingProps = textContent, existing.return = returnFiber, existing;
-        }
-        deleteRemainingChildren(returnFiber, currentFirstChild);
-        var created = createFiberFromText$1(textContent, returnFiber.internalContextTag, priority);
-        return created.return = returnFiber, created;
-    }
-    function reconcileSingleElement(returnFiber, currentFirstChild, element, priority) {
-        for (var key = element.key, child = currentFirstChild; null !== child; ) {
-            if (child.key === key) {
-                if (child.type === element.type) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    var existing = useFiber(child, priority);
-                    return existing.ref = coerceRef(child, element), existing.pendingProps = element.props, 
-                    existing.return = returnFiber, existing._debugSource = element._source, existing._debugOwner = element._owner, 
-                    existing;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-            }
-            deleteChild(returnFiber, child), child = child.sibling;
-        }
-        var created = createFiberFromElement$1(element, returnFiber.internalContextTag, priority);
-        return created.ref = coerceRef(currentFirstChild, element), created.return = returnFiber, 
-        created;
-    }
-    function reconcileSingleCoroutine(returnFiber, currentFirstChild, coroutine, priority) {
-        for (var key = coroutine.key, child = currentFirstChild; null !== child; ) {
-            if (child.key === key) {
-                if (child.tag === CoroutineComponent$2) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    var existing = useFiber(child, priority);
-                    return existing.pendingProps = coroutine, existing.return = returnFiber, existing;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-            }
-            deleteChild(returnFiber, child), child = child.sibling;
-        }
-        var created = createFiberFromCoroutine$1(coroutine, returnFiber.internalContextTag, priority);
-        return created.return = returnFiber, created;
-    }
-    function reconcileSingleYield(returnFiber, currentFirstChild, yieldNode, priority) {
-        var child = currentFirstChild;
-        if (null !== child) {
-            if (child.tag === YieldComponent$3) {
-                deleteRemainingChildren(returnFiber, child.sibling);
-                var existing = useFiber(child, priority);
-                return existing.type = yieldNode.value, existing.return = returnFiber, existing;
-            }
-            deleteRemainingChildren(returnFiber, child);
-        }
-        var created = createFiberFromYield$1(yieldNode, returnFiber.internalContextTag, priority);
-        return created.type = yieldNode.value, created.return = returnFiber, created;
-    }
-    function reconcileSinglePortal(returnFiber, currentFirstChild, portal, priority) {
-        for (var key = portal.key, child = currentFirstChild; null !== child; ) {
-            if (child.key === key) {
-                if (child.tag === HostPortal$4 && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
-                    deleteRemainingChildren(returnFiber, child.sibling);
-                    var existing = useFiber(child, priority);
-                    return existing.pendingProps = portal.children || [], existing.return = returnFiber, 
-                    existing;
-                }
-                deleteRemainingChildren(returnFiber, child);
-                break;
-            }
-            deleteChild(returnFiber, child), child = child.sibling;
-        }
-        var created = createFiberFromPortal$1(portal, returnFiber.internalContextTag, priority);
-        return created.return = returnFiber, created;
-    }
-    function reconcileChildFibers(returnFiber, currentFirstChild, newChild, priority) {
-        var disableNewFiberFeatures = ReactFeatureFlags_1.disableNewFiberFeatures, isObject = "object" == typeof newChild && null !== newChild;
-        if (isObject) if (disableNewFiberFeatures) switch (newChild.$$typeof) {
-          case REACT_ELEMENT_TYPE:
-            return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, priority));
-
-          case REACT_PORTAL_TYPE$1:
-            return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, priority));
-        } else switch (newChild.$$typeof) {
-          case REACT_ELEMENT_TYPE:
-            return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, priority));
-
-          case REACT_COROUTINE_TYPE:
-            return placeSingleChild(reconcileSingleCoroutine(returnFiber, currentFirstChild, newChild, priority));
-
-          case REACT_YIELD_TYPE:
-            return placeSingleChild(reconcileSingleYield(returnFiber, currentFirstChild, newChild, priority));
-
-          case REACT_PORTAL_TYPE$1:
-            return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, priority));
-        }
-        if (disableNewFiberFeatures) switch (returnFiber.tag) {
-          case ClassComponent$7:
-            if (returnFiber.stateNode.render._isMockFunction && void 0 === newChild) break;
-            var Component = returnFiber.type;
-            invariant(null === newChild || !1 === newChild, "%s.render(): A valid React element (or null) must be returned. " + "You may have returned undefined, an array or some other " + "invalid object.", Component.displayName || Component.name || "Component");
-            break;
-
-          case FunctionalComponent$2:
-            var _Component = returnFiber.type;
-            invariant(null === newChild || !1 === newChild, "%s(...): A valid React element (or null) must be returned. " + "You may have returned undefined, an array or some other " + "invalid object.", _Component.displayName || _Component.name || "Component");
-        }
-        if ("string" == typeof newChild || "number" == typeof newChild) return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, "" + newChild, priority));
-        if (isArray(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, priority);
-        if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, priority);
-        if (isObject && throwOnInvalidObjectType(returnFiber, newChild), !disableNewFiberFeatures && void 0 === newChild) switch (returnFiber.tag) {
-          case ClassComponent$7:
-            if (returnFiber.stateNode.render._isMockFunction) break;
-
-          case FunctionalComponent$2:
-            var _Component2 = returnFiber.type;
-            invariant(!1, "%s(...): Nothing was returned from render. This usually means a " + "return statement is missing. Or, to render nothing, " + "return null.", _Component2.displayName || _Component2.name || "Component");
-        }
-        return deleteRemainingChildren(returnFiber, currentFirstChild);
-    }
-    return reconcileChildFibers;
-}
-
-var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlace$1 = ChildReconciler(!1, !0), mountChildFibersInPlace$1 = ChildReconciler(!1, !1), cloneChildFibers$1 = function(current, workInProgress) {
-    if (invariant(null === current || workInProgress.child === current.child, "Resuming work not yet implemented."), 
-    null !== workInProgress.child) {
-        var currentChild = workInProgress.child, newChild = createWorkInProgress$2(currentChild, currentChild.pendingWorkPriority);
-        for (newChild.pendingProps = currentChild.pendingProps, workInProgress.child = newChild, 
-        newChild.return = workInProgress; null !== currentChild.sibling; ) currentChild = currentChild.sibling, 
-        newChild = newChild.sibling = createWorkInProgress$2(currentChild, currentChild.pendingWorkPriority), 
-        newChild.pendingProps = currentChild.pendingProps, newChild.return = workInProgress;
-        newChild.sibling = null;
-    }
-}, ReactChildFiber = {
-    reconcileChildFibers: reconcileChildFibers$1,
-    reconcileChildFibersInPlace: reconcileChildFibersInPlace$1,
-    mountChildFibersInPlace: mountChildFibersInPlace$1,
-    cloneChildFibers: cloneChildFibers$1
-}, Update$1 = ReactTypeOfSideEffect.Update, AsyncUpdates$1 = ReactTypeOfInternalContext.AsyncUpdates, cacheContext$1 = ReactFiberContext.cacheContext, getMaskedContext$2 = ReactFiberContext.getMaskedContext, getUnmaskedContext$2 = ReactFiberContext.getUnmaskedContext, isContextConsumer$1 = ReactFiberContext.isContextConsumer, addUpdate$1 = ReactFiberUpdateQueue.addUpdate, addReplaceUpdate$1 = ReactFiberUpdateQueue.addReplaceUpdate, addForceUpdate$1 = ReactFiberUpdateQueue.addForceUpdate, beginUpdateQueue$2 = ReactFiberUpdateQueue.beginUpdateQueue, _require5$1 = ReactFiberContext, hasContextChanged$2 = _require5$1.hasContextChanged, isMounted$1 = ReactFiberTreeReflection.isMounted, isArray$1 = Array.isArray, _require7$1 = ReactDebugFiberPerf_1, startPhaseTimer$1 = _require7$1.startPhaseTimer, stopPhaseTimer$1 = _require7$1.stopPhaseTimer, warning$8 = warning, warnOnInvalidCallback = function(callback, callerName) {
-    warning$8(null === callback || "function" == typeof callback, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
-}, ReactFiberClassComponent = function(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState) {
-    var updater = {
-        isMounted: isMounted$1,
-        enqueueSetState: function(instance, partialState, callback) {
-            var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
-            callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "setState"), 
-            addUpdate$1(fiber, partialState, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
-        },
-        enqueueReplaceState: function(instance, state, callback) {
-            var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
-            callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "replaceState"), 
-            addReplaceUpdate$1(fiber, state, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
-        },
-        enqueueForceUpdate: function(instance, callback) {
-            var fiber = ReactInstanceMap_1.get(instance), priorityLevel = getPriorityContext(fiber, !1);
-            callback = void 0 === callback ? null : callback, warnOnInvalidCallback(callback, "forceUpdate"), 
-            addForceUpdate$1(fiber, callback, priorityLevel), scheduleUpdate(fiber, priorityLevel);
-        }
-    };
-    function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
-        if (null === oldProps || null !== workInProgress.updateQueue && workInProgress.updateQueue.hasForceUpdate) return !0;
-        var instance = workInProgress.stateNode, type = workInProgress.type;
-        if ("function" == typeof instance.shouldComponentUpdate) {
-            startPhaseTimer$1(workInProgress, "shouldComponentUpdate");
-            var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext);
-            return stopPhaseTimer$1(), warning$8(void 0 !== shouldUpdate, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName_1(workInProgress) || "Unknown"), 
-            shouldUpdate;
-        }
-        return !type.prototype || !type.prototype.isPureReactComponent || (!shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState));
-    }
-    function checkClassInstance(workInProgress) {
-        var instance = workInProgress.stateNode, type = workInProgress.type, name = getComponentName_1(workInProgress), renderPresent = instance.render;
-        warning$8(renderPresent, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
-        var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
-        warning$8(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);
-        var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
-        warning$8(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);
-        var noInstancePropTypes = !instance.propTypes;
-        warning$8(noInstancePropTypes, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name);
-        var noInstanceContextTypes = !instance.contextTypes;
-        warning$8(noInstanceContextTypes, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name);
-        var noComponentShouldUpdate = "function" != typeof instance.componentShouldUpdate;
-        warning$8(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), 
-        type.prototype && type.prototype.isPureReactComponent && void 0 !== instance.shouldComponentUpdate && warning$8(!1, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName_1(workInProgress) || "A pure component");
-        var noComponentDidUnmount = "function" != typeof instance.componentDidUnmount;
-        warning$8(noComponentDidUnmount, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name);
-        var noComponentWillRecieveProps = "function" != typeof instance.componentWillRecieveProps;
-        warning$8(noComponentWillRecieveProps, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name);
-        var hasMutatedProps = instance.props !== workInProgress.pendingProps;
-        warning$8(void 0 === instance.props || !hasMutatedProps, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name);
-        var noInstanceDefaultProps = !instance.defaultProps;
-        warning$8(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);
-        var state = instance.state;
-        state && ("object" != typeof state || isArray$1(state)) && invariant(!1, "%s.state: must be set to an object or null", getComponentName_1(workInProgress)), 
-        "function" == typeof instance.getChildContext && invariant("object" == typeof workInProgress.type.childContextTypes, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", getComponentName_1(workInProgress));
-    }
-    function resetInputPointers(workInProgress, instance) {
-        instance.props = workInProgress.memoizedProps, instance.state = workInProgress.memoizedState;
-    }
-    function adoptClassInstance(workInProgress, instance) {
-        instance.updater = updater, workInProgress.stateNode = instance, ReactInstanceMap_1.set(instance, workInProgress);
-    }
-    function constructClassInstance(workInProgress, props) {
-        var ctor = workInProgress.type, unmaskedContext = getUnmaskedContext$2(workInProgress), needsContext = isContextConsumer$1(workInProgress), context = needsContext ? getMaskedContext$2(workInProgress, unmaskedContext) : emptyObject, instance = new ctor(props, context);
-        return adoptClassInstance(workInProgress, instance), needsContext && cacheContext$1(workInProgress, unmaskedContext, context), 
-        instance;
-    }
-    function callComponentWillMount(workInProgress, instance) {
-        startPhaseTimer$1(workInProgress, "componentWillMount");
-        var oldState = instance.state;
-        instance.componentWillMount(), stopPhaseTimer$1(), oldState !== instance.state && (warning$8(!1, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName_1(workInProgress)), 
-        updater.enqueueReplaceState(instance, instance.state, null));
-    }
-    function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
-        startPhaseTimer$1(workInProgress, "componentWillReceiveProps");
-        var oldState = instance.state;
-        instance.componentWillReceiveProps(newProps, newContext), stopPhaseTimer$1(), instance.state !== oldState && (warning$8(!1, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName_1(workInProgress)), 
-        updater.enqueueReplaceState(instance, instance.state, null));
-    }
-    function mountClassInstance(workInProgress, priorityLevel) {
-        var current = workInProgress.alternate;
-        checkClassInstance(workInProgress);
-        var instance = workInProgress.stateNode, state = instance.state || null, props = workInProgress.pendingProps;
-        invariant(props, "There must be pending props for an initial mount. This error is " + "likely caused by a bug in React. Please file an issue.");
-        var unmaskedContext = getUnmaskedContext$2(workInProgress);
-        if (instance.props = props, instance.state = state, instance.refs = emptyObject, 
-        instance.context = getMaskedContext$2(workInProgress, unmaskedContext), ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != workInProgress.type && !0 === workInProgress.type.unstable_asyncUpdates && (workInProgress.internalContextTag |= AsyncUpdates$1), 
-        "function" == typeof instance.componentWillMount) {
-            callComponentWillMount(workInProgress, instance);
-            var updateQueue = workInProgress.updateQueue;
-            null !== updateQueue && (instance.state = beginUpdateQueue$2(current, workInProgress, updateQueue, instance, state, props, priorityLevel));
-        }
-        "function" == typeof instance.componentDidMount && (workInProgress.effectTag |= Update$1);
-    }
-    function updateClassInstance(current, workInProgress, priorityLevel) {
-        var instance = workInProgress.stateNode;
-        resetInputPointers(workInProgress, instance);
-        var oldProps = workInProgress.memoizedProps, newProps = workInProgress.pendingProps;
-        newProps || (newProps = oldProps, invariant(null != newProps, "There should always be pending or memoized props. This error is " + "likely caused by a bug in React. Please file an issue."));
-        var oldContext = instance.context, newUnmaskedContext = getUnmaskedContext$2(workInProgress), newContext = getMaskedContext$2(workInProgress, newUnmaskedContext);
-        "function" != typeof instance.componentWillReceiveProps || oldProps === newProps && oldContext === newContext || callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
-        var oldState = workInProgress.memoizedState, newState = void 0;
-        if (newState = null !== workInProgress.updateQueue ? beginUpdateQueue$2(current, workInProgress, workInProgress.updateQueue, instance, oldState, newProps, priorityLevel) : oldState, 
-        !(oldProps !== newProps || oldState !== newState || hasContextChanged$2() || null !== workInProgress.updateQueue && workInProgress.updateQueue.hasForceUpdate)) return "function" == typeof instance.componentDidUpdate && (oldProps === current.memoizedProps && oldState === current.memoizedState || (workInProgress.effectTag |= Update$1)), 
-        !1;
-        var shouldUpdate = checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);
-        return shouldUpdate ? ("function" == typeof instance.componentWillUpdate && (startPhaseTimer$1(workInProgress, "componentWillUpdate"), 
-        instance.componentWillUpdate(newProps, newState, newContext), stopPhaseTimer$1()), 
-        "function" == typeof instance.componentDidUpdate && (workInProgress.effectTag |= Update$1)) : ("function" == typeof instance.componentDidUpdate && (oldProps === current.memoizedProps && oldState === current.memoizedState || (workInProgress.effectTag |= Update$1)), 
-        memoizeProps(workInProgress, newProps), memoizeState(workInProgress, newState)), 
-        instance.props = newProps, instance.state = newState, instance.context = newContext, 
-        shouldUpdate;
-    }
-    return {
-        adoptClassInstance: adoptClassInstance,
-        constructClassInstance: constructClassInstance,
-        mountClassInstance: mountClassInstance,
-        updateClassInstance: updateClassInstance
-    };
-}, mountChildFibersInPlace = ReactChildFiber.mountChildFibersInPlace, reconcileChildFibers = ReactChildFiber.reconcileChildFibers, reconcileChildFibersInPlace = ReactChildFiber.reconcileChildFibersInPlace, cloneChildFibers = ReactChildFiber.cloneChildFibers, beginUpdateQueue$1 = ReactFiberUpdateQueue.beginUpdateQueue, getMaskedContext$1 = ReactFiberContext.getMaskedContext, getUnmaskedContext$1 = ReactFiberContext.getUnmaskedContext, hasContextChanged$1 = ReactFiberContext.hasContextChanged, pushContextProvider$1 = ReactFiberContext.pushContextProvider, pushTopLevelContextObject$1 = ReactFiberContext.pushTopLevelContextObject, invalidateContextProvider$1 = ReactFiberContext.invalidateContextProvider, IndeterminateComponent$2 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$1 = ReactTypeOfWork.FunctionalComponent, ClassComponent$6 = ReactTypeOfWork.ClassComponent, HostRoot$6 = ReactTypeOfWork.HostRoot, HostComponent$7 = ReactTypeOfWork.HostComponent, HostText$3 = ReactTypeOfWork.HostText, HostPortal$3 = ReactTypeOfWork.HostPortal, CoroutineComponent$1 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$2 = ReactTypeOfWork.YieldComponent, Fragment$2 = ReactTypeOfWork.Fragment, NoWork$3 = ReactPriorityLevel.NoWork, OffscreenPriority$1 = ReactPriorityLevel.OffscreenPriority, PerformedWork$1 = ReactTypeOfSideEffect.PerformedWork, Placement$2 = ReactTypeOfSideEffect.Placement, ContentReset$1 = ReactTypeOfSideEffect.ContentReset, Err$1 = ReactTypeOfSideEffect.Err, Ref$1 = ReactTypeOfSideEffect.Ref, ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, ReactDebugCurrentFiber$4 = ReactDebugCurrentFiber_1, _require7 = ReactDebugFiberPerf_1, cancelWorkTimer = _require7.cancelWorkTimer, warning$6 = warning, warnedAboutStatelessRefs = {}, ReactFiberBeginWork = function(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext) {
-    var shouldSetTextContent = config.shouldSetTextContent, useSyncScheduling = config.useSyncScheduling, shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree, pushHostContext = hostContext.pushHostContext, pushHostContainer = hostContext.pushHostContainer, enterHydrationState = hydrationContext.enterHydrationState, resetHydrationState = hydrationContext.resetHydrationState, tryToClaimNextHydratableInstance = hydrationContext.tryToClaimNextHydratableInstance, _ReactFiberClassCompo = ReactFiberClassComponent(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState), adoptClassInstance = _ReactFiberClassCompo.adoptClassInstance, constructClassInstance = _ReactFiberClassCompo.constructClassInstance, mountClassInstance = _ReactFiberClassCompo.mountClassInstance, updateClassInstance = _ReactFiberClassCompo.updateClassInstance;
-    function reconcileChildren(current, workInProgress, nextChildren) {
-        reconcileChildrenAtPriority(current, workInProgress, nextChildren, workInProgress.pendingWorkPriority);
-    }
-    function reconcileChildrenAtPriority(current, workInProgress, nextChildren, priorityLevel) {
-        null === current ? workInProgress.child = mountChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel) : current.child === workInProgress.child ? workInProgress.child = reconcileChildFibers(workInProgress, workInProgress.child, nextChildren, priorityLevel) : workInProgress.child = reconcileChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel);
-    }
-    function updateFragment(current, workInProgress) {
-        var nextChildren = workInProgress.pendingProps;
-        if (hasContextChanged$1()) null === nextChildren && (nextChildren = workInProgress.memoizedProps); else if (null === nextChildren || workInProgress.memoizedProps === nextChildren) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-        return reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextChildren), 
-        workInProgress.child;
-    }
-    function markRef(current, workInProgress) {
-        var ref = workInProgress.ref;
-        null === ref || current && current.ref === ref || (workInProgress.effectTag |= Ref$1);
-    }
-    function updateFunctionalComponent(current, workInProgress) {
-        var fn = workInProgress.type, nextProps = workInProgress.pendingProps, memoizedProps = workInProgress.memoizedProps;
-        if (hasContextChanged$1()) null === nextProps && (nextProps = memoizedProps); else {
-            if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-            if ("function" == typeof fn.shouldComponentUpdate && !fn.shouldComponentUpdate(memoizedProps, nextProps)) return memoizeProps(workInProgress, nextProps), 
-            bailoutOnAlreadyFinishedWork(current, workInProgress);
-        }
-        var nextChildren, unmaskedContext = getUnmaskedContext$1(workInProgress), context = getMaskedContext$1(workInProgress, unmaskedContext);
-        return ReactCurrentOwner$2.current = workInProgress, ReactDebugCurrentFiber$4.phase = "render", 
-        nextChildren = fn(nextProps, context), ReactDebugCurrentFiber$4.phase = null, workInProgress.effectTag |= PerformedWork$1, 
-        reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextProps), 
-        workInProgress.child;
-    }
-    function updateClassComponent(current, workInProgress, priorityLevel) {
-        var hasContext = pushContextProvider$1(workInProgress), shouldUpdate = void 0;
-        return null === current ? workInProgress.stateNode ? invariant(!1, "Resuming work not yet implemented.") : (constructClassInstance(workInProgress, workInProgress.pendingProps), 
-        mountClassInstance(workInProgress, priorityLevel), shouldUpdate = !0) : shouldUpdate = updateClassInstance(current, workInProgress, priorityLevel), 
-        finishClassComponent(current, workInProgress, shouldUpdate, hasContext);
-    }
-    function finishClassComponent(current, workInProgress, shouldUpdate, hasContext) {
-        if (markRef(current, workInProgress), !shouldUpdate) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-        var instance = workInProgress.stateNode;
-        ReactCurrentOwner$2.current = workInProgress;
-        var nextChildren = void 0;
-        return ReactDebugCurrentFiber$4.phase = "render", nextChildren = instance.render(), 
-        ReactDebugCurrentFiber$4.phase = null, workInProgress.effectTag |= PerformedWork$1, 
-        reconcileChildren(current, workInProgress, nextChildren), memoizeState(workInProgress, instance.state), 
-        memoizeProps(workInProgress, instance.props), hasContext && invalidateContextProvider$1(workInProgress), 
-        workInProgress.child;
-    }
-    function updateHostRoot(current, workInProgress, priorityLevel) {
-        var root = workInProgress.stateNode;
-        root.pendingContext ? pushTopLevelContextObject$1(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject$1(workInProgress, root.context, !1), 
-        pushHostContainer(workInProgress, root.containerInfo);
-        var updateQueue = workInProgress.updateQueue;
-        if (null !== updateQueue) {
-            var prevState = workInProgress.memoizedState, state = beginUpdateQueue$1(current, workInProgress, updateQueue, null, prevState, null, priorityLevel);
-            if (prevState === state) return resetHydrationState(), bailoutOnAlreadyFinishedWork(current, workInProgress);
-            var element = state.element;
-            return null !== current && null !== current.child || !enterHydrationState(workInProgress) ? (resetHydrationState(), 
-            reconcileChildren(current, workInProgress, element)) : (workInProgress.effectTag |= Placement$2, 
-            workInProgress.child = mountChildFibersInPlace(workInProgress, workInProgress.child, element, priorityLevel)), 
-            memoizeState(workInProgress, state), workInProgress.child;
-        }
-        return resetHydrationState(), bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    function updateHostComponent(current, workInProgress, renderPriority) {
-        pushHostContext(workInProgress), null === current && tryToClaimNextHydratableInstance(workInProgress);
-        var type = workInProgress.type, memoizedProps = workInProgress.memoizedProps, nextProps = workInProgress.pendingProps;
-        null === nextProps && (nextProps = memoizedProps, invariant(null !== nextProps, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue."));
-        var prevProps = null !== current ? current.memoizedProps : null;
-        if (hasContextChanged$1()) ; else if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-        var nextChildren = nextProps.children;
-        return shouldSetTextContent(type, nextProps) ? nextChildren = null : prevProps && shouldSetTextContent(type, prevProps) && (workInProgress.effectTag |= ContentReset$1), 
-        markRef(current, workInProgress), renderPriority !== OffscreenPriority$1 && !useSyncScheduling && shouldDeprioritizeSubtree(type, nextProps) ? (workInProgress.pendingWorkPriority = OffscreenPriority$1, 
-        null) : (reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextProps), 
-        workInProgress.child);
-    }
-    function updateHostText(current, workInProgress) {
-        null === current && tryToClaimNextHydratableInstance(workInProgress);
-        var nextProps = workInProgress.pendingProps;
-        return null === nextProps && (nextProps = workInProgress.memoizedProps), memoizeProps(workInProgress, nextProps), 
-        null;
-    }
-    function mountIndeterminateComponent(current, workInProgress, priorityLevel) {
-        invariant(null === current, "An indeterminate component should never have mounted. This error is " + "likely caused by a bug in React. Please file an issue.");
-        var value, fn = workInProgress.type, props = workInProgress.pendingProps, unmaskedContext = getUnmaskedContext$1(workInProgress), context = getMaskedContext$1(workInProgress, unmaskedContext);
-        if (ReactCurrentOwner$2.current = workInProgress, value = fn(props, context), workInProgress.effectTag |= PerformedWork$1, 
-        "object" == typeof value && null !== value && "function" == typeof value.render) {
-            workInProgress.tag = ClassComponent$6;
-            var hasContext = pushContextProvider$1(workInProgress);
-            return adoptClassInstance(workInProgress, value), mountClassInstance(workInProgress, priorityLevel), 
-            finishClassComponent(current, workInProgress, !0, hasContext);
-        }
-        workInProgress.tag = FunctionalComponent$1;
-        var Component = workInProgress.type;
-        if (Component && warning$6(!Component.childContextTypes, "%s(...): childContextTypes cannot be defined on a functional component.", Component.displayName || Component.name || "Component"), 
-        null !== workInProgress.ref) {
-            var info = "", ownerName = ReactDebugCurrentFiber$4.getCurrentFiberOwnerName();
-            ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`.");
-            var warningKey = ownerName || workInProgress._debugID || "", debugSource = workInProgress._debugSource;
-            debugSource && (warningKey = debugSource.fileName + ":" + debugSource.lineNumber), 
-            warnedAboutStatelessRefs[warningKey] || (warnedAboutStatelessRefs[warningKey] = !0, 
-            warning$6(!1, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactDebugCurrentFiber$4.getCurrentFiberStackAddendum()));
-        }
-        return reconcileChildren(current, workInProgress, value), memoizeProps(workInProgress, props), 
-        workInProgress.child;
-    }
-    function updateCoroutineComponent(current, workInProgress) {
-        var nextCoroutine = workInProgress.pendingProps;
-        hasContextChanged$1() ? null === nextCoroutine && (nextCoroutine = current && current.memoizedProps, 
-        invariant(null !== nextCoroutine, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue.")) : null !== nextCoroutine && workInProgress.memoizedProps !== nextCoroutine || (nextCoroutine = workInProgress.memoizedProps);
-        var nextChildren = nextCoroutine.children, priorityLevel = workInProgress.pendingWorkPriority;
-        return null === current ? workInProgress.stateNode = mountChildFibersInPlace(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel) : current.child === workInProgress.child ? workInProgress.stateNode = reconcileChildFibers(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel) : workInProgress.stateNode = reconcileChildFibersInPlace(workInProgress, workInProgress.stateNode, nextChildren, priorityLevel), 
-        memoizeProps(workInProgress, nextCoroutine), workInProgress.stateNode;
-    }
-    function updatePortalComponent(current, workInProgress) {
-        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-        var priorityLevel = workInProgress.pendingWorkPriority, nextChildren = workInProgress.pendingProps;
-        if (hasContextChanged$1()) null === nextChildren && (nextChildren = current && current.memoizedProps, 
-        invariant(null != nextChildren, "We should always have pending or current props. This error is " + "likely caused by a bug in React. Please file an issue.")); else if (null === nextChildren || workInProgress.memoizedProps === nextChildren) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-        return null === current ? (workInProgress.child = reconcileChildFibersInPlace(workInProgress, workInProgress.child, nextChildren, priorityLevel), 
-        memoizeProps(workInProgress, nextChildren)) : (reconcileChildren(current, workInProgress, nextChildren), 
-        memoizeProps(workInProgress, nextChildren)), workInProgress.child;
-    }
-    function bailoutOnAlreadyFinishedWork(current, workInProgress) {
-        return cancelWorkTimer(workInProgress), cloneChildFibers(current, workInProgress), 
-        workInProgress.child;
-    }
-    function bailoutOnLowPriority(current, workInProgress) {
-        switch (cancelWorkTimer(workInProgress), workInProgress.tag) {
-          case ClassComponent$6:
-            pushContextProvider$1(workInProgress);
-            break;
-
-          case HostPortal$3:
-            pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-        }
-        return null;
-    }
-    function memoizeProps(workInProgress, nextProps) {
-        workInProgress.memoizedProps = nextProps;
-    }
-    function memoizeState(workInProgress, nextState) {
-        workInProgress.memoizedState = nextState;
-    }
-    function beginWork(current, workInProgress, priorityLevel) {
-        if (workInProgress.pendingWorkPriority === NoWork$3 || workInProgress.pendingWorkPriority > priorityLevel) return bailoutOnLowPriority(current, workInProgress);
-        switch (ReactDebugCurrentFiber$4.current = workInProgress, workInProgress.tag) {
-          case IndeterminateComponent$2:
-            return mountIndeterminateComponent(current, workInProgress, priorityLevel);
-
-          case FunctionalComponent$1:
-            return updateFunctionalComponent(current, workInProgress);
-
-          case ClassComponent$6:
-            return updateClassComponent(current, workInProgress, priorityLevel);
-
-          case HostRoot$6:
-            return updateHostRoot(current, workInProgress, priorityLevel);
-
-          case HostComponent$7:
-            return updateHostComponent(current, workInProgress, priorityLevel);
-
-          case HostText$3:
-            return updateHostText(current, workInProgress);
-
-          case CoroutineHandlerPhase:
-            workInProgress.tag = CoroutineComponent$1;
-
-          case CoroutineComponent$1:
-            return updateCoroutineComponent(current, workInProgress);
-
-          case YieldComponent$2:
-            return null;
-
-          case HostPortal$3:
-            return updatePortalComponent(current, workInProgress);
-
-          case Fragment$2:
-            return updateFragment(current, workInProgress);
-
-          default:
-            invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
-        }
-    }
-    function beginFailedWork(current, workInProgress, priorityLevel) {
-        if (invariant(workInProgress.tag === ClassComponent$6 || workInProgress.tag === HostRoot$6, "Invalid type of work. This error is likely caused by a bug in React. " + "Please file an issue."), 
-        workInProgress.effectTag |= Err$1, null === current ? workInProgress.child = null : workInProgress.child !== current.child && (workInProgress.child = current.child), 
-        workInProgress.pendingWorkPriority === NoWork$3 || workInProgress.pendingWorkPriority > priorityLevel) return bailoutOnLowPriority(current, workInProgress);
-        if (workInProgress.firstEffect = null, workInProgress.lastEffect = null, reconcileChildrenAtPriority(current, workInProgress, null, priorityLevel), 
-        workInProgress.tag === ClassComponent$6) {
-            var instance = workInProgress.stateNode;
-            workInProgress.memoizedProps = instance.props, workInProgress.memoizedState = instance.state;
-        }
-        return workInProgress.child;
-    }
-    return {
-        beginWork: beginWork,
-        beginFailedWork: beginFailedWork
-    };
-}, reconcileChildFibers$2 = ReactChildFiber.reconcileChildFibers, popContextProvider$2 = ReactFiberContext.popContextProvider, IndeterminateComponent$3 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$3 = ReactTypeOfWork.FunctionalComponent, ClassComponent$8 = ReactTypeOfWork.ClassComponent, HostRoot$7 = ReactTypeOfWork.HostRoot, HostComponent$8 = ReactTypeOfWork.HostComponent, HostText$5 = ReactTypeOfWork.HostText, HostPortal$5 = ReactTypeOfWork.HostPortal, CoroutineComponent$3 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase$1 = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$4 = ReactTypeOfWork.YieldComponent, Fragment$4 = ReactTypeOfWork.Fragment, Placement$4 = ReactTypeOfSideEffect.Placement, Ref$2 = ReactTypeOfSideEffect.Ref, Update$2 = ReactTypeOfSideEffect.Update, OffscreenPriority$2 = ReactPriorityLevel.OffscreenPriority, ReactDebugCurrentFiber$5 = ReactDebugCurrentFiber_1, ReactFiberCompleteWork = function(config, hostContext, hydrationContext) {
-    var createInstance = config.createInstance, createTextInstance = config.createTextInstance, appendInitialChild = config.appendInitialChild, finalizeInitialChildren = config.finalizeInitialChildren, prepareUpdate = config.prepareUpdate, getRootHostContainer = hostContext.getRootHostContainer, popHostContext = hostContext.popHostContext, getHostContext = hostContext.getHostContext, popHostContainer = hostContext.popHostContainer, prepareToHydrateHostInstance = hydrationContext.prepareToHydrateHostInstance, prepareToHydrateHostTextInstance = hydrationContext.prepareToHydrateHostTextInstance, popHydrationState = hydrationContext.popHydrationState;
-    function markUpdate(workInProgress) {
-        workInProgress.effectTag |= Update$2;
-    }
-    function markRef(workInProgress) {
-        workInProgress.effectTag |= Ref$2;
-    }
-    function appendAllYields(yields, workInProgress) {
-        var node = workInProgress.stateNode;
-        for (node && (node.return = workInProgress); null !== node; ) {
-            if (node.tag === HostComponent$8 || node.tag === HostText$5 || node.tag === HostPortal$5) invariant(!1, "A coroutine cannot have host component children."); else if (node.tag === YieldComponent$4) yields.push(node.type); else if (null !== node.child) {
-                node.child.return = node, node = node.child;
-                continue;
-            }
-            for (;null === node.sibling; ) {
-                if (null === node.return || node.return === workInProgress) return;
-                node = node.return;
-            }
-            node.sibling.return = node.return, node = node.sibling;
-        }
-    }
-    function moveCoroutineToHandlerPhase(current, workInProgress) {
-        var coroutine = workInProgress.memoizedProps;
-        invariant(coroutine, "Should be resolved by now. This error is likely caused by a bug in " + "React. Please file an issue."), 
-        workInProgress.tag = CoroutineHandlerPhase$1;
-        var yields = [];
-        appendAllYields(yields, workInProgress);
-        var fn = coroutine.handler, props = coroutine.props, nextChildren = fn(props, yields), currentFirstChild = null !== current ? current.child : null, priority = workInProgress.pendingWorkPriority;
-        return workInProgress.child = reconcileChildFibers$2(workInProgress, currentFirstChild, nextChildren, priority), 
-        workInProgress.child;
-    }
-    function appendAllChildren(parent, workInProgress) {
-        for (var node = workInProgress.child; null !== node; ) {
-            if (node.tag === HostComponent$8 || node.tag === HostText$5) appendInitialChild(parent, node.stateNode); else if (node.tag === HostPortal$5) ; else if (null !== node.child) {
-                node = node.child;
-                continue;
-            }
-            if (node === workInProgress) return;
-            for (;null === node.sibling; ) {
-                if (null === node.return || node.return === workInProgress) return;
-                node = node.return;
-            }
-            node = node.sibling;
-        }
-    }
-    function completeWork(current, workInProgress, renderPriority) {
-        ReactDebugCurrentFiber$5.current = workInProgress;
-        var newProps = workInProgress.pendingProps;
-        switch (null === newProps ? newProps = workInProgress.memoizedProps : workInProgress.pendingWorkPriority === OffscreenPriority$2 && renderPriority !== OffscreenPriority$2 || (workInProgress.pendingProps = null), 
-        workInProgress.tag) {
-          case FunctionalComponent$3:
-            return null;
-
-          case ClassComponent$8:
-            return popContextProvider$2(workInProgress), null;
-
-          case HostRoot$7:
-            var fiberRoot = workInProgress.stateNode;
-            return fiberRoot.pendingContext && (fiberRoot.context = fiberRoot.pendingContext, 
-            fiberRoot.pendingContext = null), null !== current && null !== current.child || (popHydrationState(workInProgress), 
-            workInProgress.effectTag &= ~Placement$4), null;
-
-          case HostComponent$8:
-            popHostContext(workInProgress);
-            var rootContainerInstance = getRootHostContainer(), type = workInProgress.type;
-            if (null !== current && null != workInProgress.stateNode) {
-                var oldProps = current.memoizedProps, instance = workInProgress.stateNode, currentHostContext = getHostContext(), updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
-                workInProgress.updateQueue = updatePayload, updatePayload && markUpdate(workInProgress), 
-                current.ref !== workInProgress.ref && markRef(workInProgress);
-            } else {
-                if (!newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue."), 
-                null;
-                var _currentHostContext = getHostContext();
-                if (popHydrationState(workInProgress)) prepareToHydrateHostInstance(workInProgress, rootContainerInstance) && markUpdate(workInProgress); else {
-                    var _instance = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress);
-                    appendAllChildren(_instance, workInProgress), finalizeInitialChildren(_instance, type, newProps, rootContainerInstance) && markUpdate(workInProgress), 
-                    workInProgress.stateNode = _instance;
-                }
-                null !== workInProgress.ref && markRef(workInProgress);
-            }
-            return null;
-
-          case HostText$5:
-            var newText = newProps;
-            if (current && null != workInProgress.stateNode) {
-                current.memoizedProps !== newText && markUpdate(workInProgress);
-            } else {
-                if ("string" != typeof newText) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue."), 
-                null;
-                var _rootContainerInstance = getRootHostContainer(), _currentHostContext2 = getHostContext();
-                popHydrationState(workInProgress) ? prepareToHydrateHostTextInstance(workInProgress) && markUpdate(workInProgress) : workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress);
-            }
-            return null;
-
-          case CoroutineComponent$3:
-            return moveCoroutineToHandlerPhase(current, workInProgress);
-
-          case CoroutineHandlerPhase$1:
-            return workInProgress.tag = CoroutineComponent$3, null;
-
-          case YieldComponent$4:
-          case Fragment$4:
-            return null;
-
-          case HostPortal$5:
-            return markUpdate(workInProgress), popHostContainer(workInProgress), null;
-
-          case IndeterminateComponent$3:
-            invariant(!1, "An indeterminate component should have become determinate before " + "completing. This error is likely caused by a bug in React. Please " + "file an issue.");
-
-          default:
-            invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
-        }
-    }
-    return {
-        completeWork: completeWork
-    };
-}, rendererID = null, injectInternals$1 = null, onCommitRoot$1 = null, onCommitUnmount$1 = null;
-
-if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && __REACT_DEVTOOLS_GLOBAL_HOOK__.supportsFiber) {
-    var inject$1 = __REACT_DEVTOOLS_GLOBAL_HOOK__.inject, onCommitFiberRoot = __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot, onCommitFiberUnmount = __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberUnmount;
-    injectInternals$1 = function(internals) {
-        warning(null == rendererID, "Cannot inject into DevTools twice."), rendererID = inject$1(internals);
-    }, onCommitRoot$1 = function(root) {
-        if (null != rendererID) try {
-            onCommitFiberRoot(rendererID, root);
-        } catch (err) {
-            warning(!1, "React DevTools encountered an error: %s", err);
-        }
-    }, onCommitUnmount$1 = function(fiber) {
-        if (null != rendererID) try {
-            onCommitFiberUnmount(rendererID, fiber);
-        } catch (err) {
-            warning(!1, "React DevTools encountered an error: %s", err);
-        }
-    };
-}
-
-var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCommitUnmount_1 = onCommitUnmount$1, ReactFiberDevToolsHook = {
-    injectInternals: injectInternals_1,
-    onCommitRoot: onCommitRoot_1,
-    onCommitUnmount: onCommitUnmount_1
-}, ClassComponent$9 = ReactTypeOfWork.ClassComponent, HostRoot$8 = ReactTypeOfWork.HostRoot, HostComponent$9 = ReactTypeOfWork.HostComponent, HostText$6 = ReactTypeOfWork.HostText, HostPortal$6 = ReactTypeOfWork.HostPortal, CoroutineComponent$4 = ReactTypeOfWork.CoroutineComponent, commitCallbacks$1 = ReactFiberUpdateQueue.commitCallbacks, onCommitUnmount = ReactFiberDevToolsHook.onCommitUnmount, invokeGuardedCallback$2 = ReactErrorUtils_1.invokeGuardedCallback, Placement$5 = ReactTypeOfSideEffect.Placement, Update$3 = ReactTypeOfSideEffect.Update, Callback$1 = ReactTypeOfSideEffect.Callback, ContentReset$2 = ReactTypeOfSideEffect.ContentReset, _require5$2 = ReactDebugFiberPerf_1, startPhaseTimer$2 = _require5$2.startPhaseTimer, stopPhaseTimer$2 = _require5$2.stopPhaseTimer, ReactFiberCommitWork = function(config, captureError) {
-    var commitMount = config.commitMount, commitUpdate = config.commitUpdate, resetTextContent = config.resetTextContent, commitTextUpdate = config.commitTextUpdate, appendChild = config.appendChild, appendChildToContainer = config.appendChildToContainer, insertBefore = config.insertBefore, insertInContainerBefore = config.insertInContainerBefore, removeChild = config.removeChild, removeChildFromContainer = config.removeChildFromContainer, getPublicInstance = config.getPublicInstance, callComponentWillUnmountWithTimerInDev = function(current, instance) {
-        startPhaseTimer$2(current, "componentWillUnmount"), instance.componentWillUnmount(), 
-        stopPhaseTimer$2();
-    };
-    function safelyCallComponentWillUnmount(current, instance) {
-        var unmountError = invokeGuardedCallback$2(null, callComponentWillUnmountWithTimerInDev, null, current, instance);
-        unmountError && captureError(current, unmountError);
-    }
-    function safelyDetachRef(current) {
-        var ref = current.ref;
-        if (null !== ref) {
-            var refError = invokeGuardedCallback$2(null, ref, null, null);
-            null !== refError && captureError(current, refError);
-        }
-    }
-    function getHostParentFiber(fiber) {
-        for (var parent = fiber.return; null !== parent; ) {
-            if (isHostParent(parent)) return parent;
-            parent = parent.return;
-        }
-        invariant(!1, "Expected to find a host parent. This error is likely caused by a bug " + "in React. Please file an issue.");
-    }
-    function isHostParent(fiber) {
-        return fiber.tag === HostComponent$9 || fiber.tag === HostRoot$8 || fiber.tag === HostPortal$6;
-    }
-    function getHostSibling(fiber) {
-        var node = fiber;
-        siblings: for (;!0; ) {
-            for (;null === node.sibling; ) {
-                if (null === node.return || isHostParent(node.return)) return null;
-                node = node.return;
-            }
-            for (node.sibling.return = node.return, node = node.sibling; node.tag !== HostComponent$9 && node.tag !== HostText$6; ) {
-                if (node.effectTag & Placement$5) continue siblings;
-                if (null === node.child || node.tag === HostPortal$6) continue siblings;
-                node.child.return = node, node = node.child;
-            }
-            if (!(node.effectTag & Placement$5)) return node.stateNode;
-        }
-    }
-    function commitPlacement(finishedWork) {
-        var parentFiber = getHostParentFiber(finishedWork), parent = void 0, isContainer = void 0;
-        switch (parentFiber.tag) {
-          case HostComponent$9:
-            parent = parentFiber.stateNode, isContainer = !1;
-            break;
-
-          case HostRoot$8:
-          case HostPortal$6:
-            parent = parentFiber.stateNode.containerInfo, isContainer = !0;
-            break;
-
-          default:
-            invariant(!1, "Invalid host parent fiber. This error is likely caused by a bug " + "in React. Please file an issue.");
-        }
-        parentFiber.effectTag & ContentReset$2 && (resetTextContent(parent), parentFiber.effectTag &= ~ContentReset$2);
-        for (var before = getHostSibling(finishedWork), node = finishedWork; !0; ) {
-            if (node.tag === HostComponent$9 || node.tag === HostText$6) before ? isContainer ? insertInContainerBefore(parent, node.stateNode, before) : insertBefore(parent, node.stateNode, before) : isContainer ? appendChildToContainer(parent, node.stateNode) : appendChild(parent, node.stateNode); else if (node.tag === HostPortal$6) ; else if (null !== node.child) {
-                node.child.return = node, node = node.child;
-                continue;
-            }
-            if (node === finishedWork) return;
-            for (;null === node.sibling; ) {
-                if (null === node.return || node.return === finishedWork) return;
-                node = node.return;
-            }
-            node.sibling.return = node.return, node = node.sibling;
-        }
-    }
-    function commitNestedUnmounts(root) {
-        for (var node = root; !0; ) if (commitUnmount(node), null === node.child || node.tag === HostPortal$6) {
-            if (node === root) return;
-            for (;null === node.sibling; ) {
-                if (null === node.return || node.return === root) return;
-                node = node.return;
-            }
-            node.sibling.return = node.return, node = node.sibling;
-        } else node.child.return = node, node = node.child;
-    }
-    function unmountHostComponents(current) {
-        for (var node = current, currentParentIsValid = !1, currentParent = void 0, currentParentIsContainer = void 0; !0; ) {
-            if (!currentParentIsValid) {
-                var parent = node.return;
-                findParent: for (;!0; ) {
-                    switch (invariant(null !== parent, "Expected to find a host parent. This error is likely caused by " + "a bug in React. Please file an issue."), 
-                    parent.tag) {
-                      case HostComponent$9:
-                        currentParent = parent.stateNode, currentParentIsContainer = !1;
-                        break findParent;
-
-                      case HostRoot$8:
-                      case HostPortal$6:
-                        currentParent = parent.stateNode.containerInfo, currentParentIsContainer = !0;
-                        break findParent;
-                    }
-                    parent = parent.return;
-                }
-                currentParentIsValid = !0;
-            }
-            if (node.tag === HostComponent$9 || node.tag === HostText$6) commitNestedUnmounts(node), 
-            currentParentIsContainer ? removeChildFromContainer(currentParent, node.stateNode) : removeChild(currentParent, node.stateNode); else if (node.tag === HostPortal$6) {
-                if (currentParent = node.stateNode.containerInfo, null !== node.child) {
-                    node.child.return = node, node = node.child;
-                    continue;
-                }
-            } else if (commitUnmount(node), null !== node.child) {
-                node.child.return = node, node = node.child;
-                continue;
-            }
-            if (node === current) return;
-            for (;null === node.sibling; ) {
-                if (null === node.return || node.return === current) return;
-                node = node.return, node.tag === HostPortal$6 && (currentParentIsValid = !1);
-            }
-            node.sibling.return = node.return, node = node.sibling;
-        }
-    }
-    function commitDeletion(current) {
-        unmountHostComponents(current), current.return = null, current.child = null, current.alternate && (current.alternate.child = null, 
-        current.alternate.return = null);
-    }
-    function commitUnmount(current) {
-        switch ("function" == typeof onCommitUnmount && onCommitUnmount(current), current.tag) {
-          case ClassComponent$9:
-            safelyDetachRef(current);
-            var instance = current.stateNode;
-            return void ("function" == typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(current, instance));
-
-          case HostComponent$9:
-            return void safelyDetachRef(current);
-
-          case CoroutineComponent$4:
-            return void commitNestedUnmounts(current.stateNode);
-
-          case HostPortal$6:
-            return void unmountHostComponents(current);
-        }
-    }
-    function commitWork(current, finishedWork) {
-        switch (finishedWork.tag) {
-          case ClassComponent$9:
-            return;
-
-          case HostComponent$9:
-            var instance = finishedWork.stateNode;
-            if (null != instance) {
-                var newProps = finishedWork.memoizedProps, oldProps = null !== current ? current.memoizedProps : newProps, type = finishedWork.type, updatePayload = finishedWork.updateQueue;
-                finishedWork.updateQueue = null, null !== updatePayload && commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
-            }
-            return;
-
-          case HostText$6:
-            invariant(null !== finishedWork.stateNode, "This should have a text node initialized. This error is likely " + "caused by a bug in React. Please file an issue.");
-            var textInstance = finishedWork.stateNode, newText = finishedWork.memoizedProps, oldText = null !== current ? current.memoizedProps : newText;
-            return void commitTextUpdate(textInstance, oldText, newText);
-
-          case HostRoot$8:
-          case HostPortal$6:
-            return;
-
-          default:
-            invariant(!1, "This unit of work tag should not have side-effects. This error is " + "likely caused by a bug in React. Please file an issue.");
-        }
-    }
-    function commitLifeCycles(current, finishedWork) {
-        switch (finishedWork.tag) {
-          case ClassComponent$9:
-            var instance = finishedWork.stateNode;
-            if (finishedWork.effectTag & Update$3) if (null === current) startPhaseTimer$2(finishedWork, "componentDidMount"), 
-            instance.componentDidMount(), stopPhaseTimer$2(); else {
-                var prevProps = current.memoizedProps, prevState = current.memoizedState;
-                startPhaseTimer$2(finishedWork, "componentDidUpdate"), instance.componentDidUpdate(prevProps, prevState), 
-                stopPhaseTimer$2();
-            }
-            return void (finishedWork.effectTag & Callback$1 && null !== finishedWork.updateQueue && commitCallbacks$1(finishedWork, finishedWork.updateQueue, instance));
-
-          case HostRoot$8:
-            var updateQueue = finishedWork.updateQueue;
-            if (null !== updateQueue) {
-                var _instance = finishedWork.child && finishedWork.child.stateNode;
-                commitCallbacks$1(finishedWork, updateQueue, _instance);
-            }
-            return;
-
-          case HostComponent$9:
-            var _instance2 = finishedWork.stateNode;
-            if (null === current && finishedWork.effectTag & Update$3) {
-                var type = finishedWork.type, props = finishedWork.memoizedProps;
-                commitMount(_instance2, type, props, finishedWork);
-            }
-            return;
-
-          case HostText$6:
-          case HostPortal$6:
-            return;
-
-          default:
-            invariant(!1, "This unit of work tag should not have side-effects. This error is " + "likely caused by a bug in React. Please file an issue.");
-        }
-    }
-    function commitAttachRef(finishedWork) {
-        var ref = finishedWork.ref;
-        if (null !== ref) {
-            var instance = finishedWork.stateNode;
-            switch (finishedWork.tag) {
-              case HostComponent$9:
-                ref(getPublicInstance(instance));
-                break;
-
-              default:
-                ref(instance);
-            }
-        }
-    }
-    function commitDetachRef(current) {
-        var currentRef = current.ref;
-        null !== currentRef && currentRef(null);
-    }
-    return {
-        commitPlacement: commitPlacement,
-        commitDeletion: commitDeletion,
-        commitWork: commitWork,
-        commitLifeCycles: commitLifeCycles,
-        commitAttachRef: commitAttachRef,
-        commitDetachRef: commitDetachRef
-    };
-}, createCursor$2 = ReactFiberStack.createCursor, pop$2 = ReactFiberStack.pop, push$2 = ReactFiberStack.push, NO_CONTEXT = {}, ReactFiberHostContext = function(config) {
-    var getChildHostContext = config.getChildHostContext, getRootHostContext = config.getRootHostContext, contextStackCursor = createCursor$2(NO_CONTEXT), contextFiberStackCursor = createCursor$2(NO_CONTEXT), rootInstanceStackCursor = createCursor$2(NO_CONTEXT);
-    function requiredContext(c) {
-        return invariant(c !== NO_CONTEXT, "Expected host context to exist. This error is likely caused by a bug " + "in React. Please file an issue."), 
-        c;
-    }
-    function getRootHostContainer() {
-        return requiredContext(rootInstanceStackCursor.current);
-    }
-    function pushHostContainer(fiber, nextRootInstance) {
-        push$2(rootInstanceStackCursor, nextRootInstance, fiber);
-        var nextRootContext = getRootHostContext(nextRootInstance);
-        push$2(contextFiberStackCursor, fiber, fiber), push$2(contextStackCursor, nextRootContext, fiber);
-    }
-    function popHostContainer(fiber) {
-        pop$2(contextStackCursor, fiber), pop$2(contextFiberStackCursor, fiber), pop$2(rootInstanceStackCursor, fiber);
-    }
-    function getHostContext() {
-        return requiredContext(contextStackCursor.current);
-    }
-    function pushHostContext(fiber) {
-        var rootInstance = requiredContext(rootInstanceStackCursor.current), context = requiredContext(contextStackCursor.current), nextContext = getChildHostContext(context, fiber.type, rootInstance);
-        context !== nextContext && (push$2(contextFiberStackCursor, fiber, fiber), push$2(contextStackCursor, nextContext, fiber));
-    }
-    function popHostContext(fiber) {
-        contextFiberStackCursor.current === fiber && (pop$2(contextStackCursor, fiber), 
-        pop$2(contextFiberStackCursor, fiber));
-    }
-    function resetHostContainer() {
-        contextStackCursor.current = NO_CONTEXT, rootInstanceStackCursor.current = NO_CONTEXT;
-    }
-    return {
-        getHostContext: getHostContext,
-        getRootHostContainer: getRootHostContainer,
-        popHostContainer: popHostContainer,
-        popHostContext: popHostContext,
-        pushHostContainer: pushHostContainer,
-        pushHostContext: pushHostContext,
-        resetHostContainer: resetHostContainer
-    };
-}, HostComponent$10 = ReactTypeOfWork.HostComponent, HostText$7 = ReactTypeOfWork.HostText, HostRoot$9 = ReactTypeOfWork.HostRoot, Deletion$2 = ReactTypeOfSideEffect.Deletion, Placement$6 = ReactTypeOfSideEffect.Placement, createFiberFromHostInstanceForDeletion$1 = ReactFiber.createFiberFromHostInstanceForDeletion, ReactFiberHydrationContext = function(config) {
-    var shouldSetTextContent = config.shouldSetTextContent, canHydrateInstance = config.canHydrateInstance, canHydrateTextInstance = config.canHydrateTextInstance, getNextHydratableSibling = config.getNextHydratableSibling, getFirstHydratableChild = config.getFirstHydratableChild, hydrateInstance = config.hydrateInstance, hydrateTextInstance = config.hydrateTextInstance, didNotHydrateInstance = config.didNotHydrateInstance, didNotFindHydratableInstance = config.didNotFindHydratableInstance, didNotFindHydratableTextInstance = config.didNotFindHydratableTextInstance;
-    if (!(canHydrateInstance && canHydrateTextInstance && getNextHydratableSibling && getFirstHydratableChild && hydrateInstance && hydrateTextInstance && didNotHydrateInstance && didNotFindHydratableInstance && didNotFindHydratableTextInstance)) return {
-        enterHydrationState: function() {
-            return !1;
-        },
-        resetHydrationState: function() {},
-        tryToClaimNextHydratableInstance: function() {},
-        prepareToHydrateHostInstance: function() {
-            invariant(!1, "React bug.");
-        },
-        prepareToHydrateHostTextInstance: function() {
-            invariant(!1, "React bug.");
-        },
-        popHydrationState: function(fiber) {
-            return !1;
-        }
-    };
-    var hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
-    function enterHydrationState(fiber) {
-        var parentInstance = fiber.stateNode.containerInfo;
-        return nextHydratableInstance = getFirstHydratableChild(parentInstance), hydrationParentFiber = fiber, 
-        isHydrating = !0, !0;
-    }
-    function deleteHydratableInstance(returnFiber, instance) {
-        switch (returnFiber.tag) {
-          case HostRoot$9:
-            didNotHydrateInstance(returnFiber.stateNode.containerInfo, instance);
-            break;
-
-          case HostComponent$10:
-            didNotHydrateInstance(returnFiber.stateNode, instance);
-        }
-        var childToDelete = createFiberFromHostInstanceForDeletion$1();
-        childToDelete.stateNode = instance, childToDelete.return = returnFiber, childToDelete.effectTag = Deletion$2, 
-        null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = childToDelete, 
-        returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
-    }
-    function insertNonHydratedInstance(returnFiber, fiber) {
-        fiber.effectTag |= Placement$6;
-        var parentInstance;
-        switch (returnFiber.tag) {
-          case HostComponent$10:
-            parentInstance = returnFiber.stateNode;
-            break;
-
-          default:
-            return;
-        }
-        switch (fiber.tag) {
-          case HostComponent$10:
-            var type = fiber.type, props = fiber.pendingProps;
-            didNotFindHydratableInstance(parentInstance, type, props);
-            break;
-
-          case HostText$7:
-            var text = fiber.pendingProps;
-            didNotFindHydratableTextInstance(parentInstance, text);
-        }
-    }
-    function canHydrate(fiber, nextInstance) {
-        switch (fiber.tag) {
-          case HostComponent$10:
-            var type = fiber.type, props = fiber.pendingProps;
-            return canHydrateInstance(nextInstance, type, props);
-
-          case HostText$7:
-            var text = fiber.pendingProps;
-            return canHydrateTextInstance(nextInstance, text);
-
-          default:
-            return !1;
-        }
-    }
-    function tryToClaimNextHydratableInstance(fiber) {
-        if (isHydrating) {
-            var nextInstance = nextHydratableInstance;
-            if (!nextInstance) return insertNonHydratedInstance(hydrationParentFiber, fiber), 
-            isHydrating = !1, void (hydrationParentFiber = fiber);
-            if (!canHydrate(fiber, nextInstance)) {
-                if (!(nextInstance = getNextHydratableSibling(nextInstance)) || !canHydrate(fiber, nextInstance)) return insertNonHydratedInstance(hydrationParentFiber, fiber), 
-                isHydrating = !1, void (hydrationParentFiber = fiber);
-                deleteHydratableInstance(hydrationParentFiber, nextHydratableInstance);
-            }
-            fiber.stateNode = nextInstance, hydrationParentFiber = fiber, nextHydratableInstance = getFirstHydratableChild(nextInstance);
-        }
-    }
-    function prepareToHydrateHostInstance(fiber, rootContainerInstance) {
-        var instance = fiber.stateNode, updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, fiber);
-        return fiber.updateQueue = updatePayload, null !== updatePayload;
-    }
-    function prepareToHydrateHostTextInstance(fiber) {
-        var textInstance = fiber.stateNode;
-        return hydrateTextInstance(textInstance, fiber.memoizedProps, fiber);
-    }
-    function popToNextHostParent(fiber) {
-        for (var parent = fiber.return; null !== parent && parent.tag !== HostComponent$10 && parent.tag !== HostRoot$9; ) parent = parent.return;
-        hydrationParentFiber = parent;
-    }
-    function popHydrationState(fiber) {
-        if (fiber !== hydrationParentFiber) return !1;
-        if (!isHydrating) return popToNextHostParent(fiber), isHydrating = !0, !1;
-        var type = fiber.type;
-        if (fiber.tag !== HostComponent$10 || "head" !== type && "body" !== type && !shouldSetTextContent(type, fiber.memoizedProps)) for (var nextInstance = nextHydratableInstance; nextInstance; ) deleteHydratableInstance(fiber, nextInstance), 
-        nextInstance = getNextHydratableSibling(nextInstance);
-        return popToNextHostParent(fiber), nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null, 
-        !0;
-    }
-    function resetHydrationState() {
-        hydrationParentFiber = null, nextHydratableInstance = null, isHydrating = !1;
-    }
-    return {
-        enterHydrationState: enterHydrationState,
-        resetHydrationState: resetHydrationState,
-        tryToClaimNextHydratableInstance: tryToClaimNextHydratableInstance,
-        prepareToHydrateHostInstance: prepareToHydrateHostInstance,
-        prepareToHydrateHostTextInstance: prepareToHydrateHostTextInstance,
-        popHydrationState: popHydrationState
-    };
-}, ReactFiberInstrumentation$2 = {
-    debugTool: null
-}, ReactFiberInstrumentation_1 = ReactFiberInstrumentation$2, popContextProvider$1 = ReactFiberContext.popContextProvider, reset$1 = ReactFiberStack.reset, getStackAddendumByWorkInProgressFiber$2 = ReactFiberComponentTreeHook.getStackAddendumByWorkInProgressFiber, logCapturedError$1 = ReactFiberErrorLogger.logCapturedError, invokeGuardedCallback$1 = ReactErrorUtils_1.invokeGuardedCallback, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, createWorkInProgress$1 = ReactFiber.createWorkInProgress, largerPriority$1 = ReactFiber.largerPriority, onCommitRoot = ReactFiberDevToolsHook.onCommitRoot, NoWork$2 = ReactPriorityLevel.NoWork, SynchronousPriority$1 = ReactPriorityLevel.SynchronousPriority, TaskPriority$1 = ReactPriorityLevel.TaskPriority, HighPriority = ReactPriorityLevel.HighPriority, LowPriority = ReactPriorityLevel.LowPriority, OffscreenPriority = ReactPriorityLevel.OffscreenPriority, AsyncUpdates = ReactTypeOfInternalContext.AsyncUpdates, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement$1 = ReactTypeOfSideEffect.Placement, Update = ReactTypeOfSideEffect.Update, PlacementAndUpdate = ReactTypeOfSideEffect.PlacementAndUpdate, Deletion = ReactTypeOfSideEffect.Deletion, ContentReset = ReactTypeOfSideEffect.ContentReset, Callback = ReactTypeOfSideEffect.Callback, Err = ReactTypeOfSideEffect.Err, Ref = ReactTypeOfSideEffect.Ref, HostRoot$5 = ReactTypeOfWork.HostRoot, HostComponent$6 = ReactTypeOfWork.HostComponent, HostPortal$2 = ReactTypeOfWork.HostPortal, ClassComponent$5 = ReactTypeOfWork.ClassComponent, getUpdatePriority$1 = ReactFiberUpdateQueue.getUpdatePriority, _require14 = ReactFiberContext, resetContext$1 = _require14.resetContext, warning$5 = warning, ReactFiberInstrumentation$1 = ReactFiberInstrumentation_1, ReactDebugCurrentFiber$3 = ReactDebugCurrentFiber_1, _require15 = ReactDebugFiberPerf_1, recordEffect = _require15.recordEffect, recordScheduleUpdate = _require15.recordScheduleUpdate, startWorkTimer = _require15.startWorkTimer, stopWorkTimer = _require15.stopWorkTimer, startWorkLoopTimer = _require15.startWorkLoopTimer, stopWorkLoopTimer = _require15.stopWorkLoopTimer, startCommitTimer = _require15.startCommitTimer, stopCommitTimer = _require15.stopCommitTimer, startCommitHostEffectsTimer = _require15.startCommitHostEffectsTimer, stopCommitHostEffectsTimer = _require15.stopCommitHostEffectsTimer, startCommitLifeCyclesTimer = _require15.startCommitLifeCyclesTimer, stopCommitLifeCyclesTimer = _require15.stopCommitLifeCyclesTimer, warnAboutUpdateOnUnmounted = function(instance) {
-    var ctor = instance.constructor;
-    warning$5(!1, "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.", ctor && (ctor.displayName || ctor.name) || "ReactClass");
-}, warnAboutInvalidUpdates = function(instance) {
-    switch (ReactDebugCurrentFiber$3.phase) {
-      case "getChildContext":
-        warning$5(!1, "setState(...): Cannot call setState() inside getChildContext()");
-        break;
-
-      case "render":
-        warning$5(!1, "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`.");
-    }
-}, timeHeuristicForUnitOfWork = 1, ReactFiberScheduler = function(config) {
-    var hostContext = ReactFiberHostContext(config), hydrationContext = ReactFiberHydrationContext(config), popHostContainer = hostContext.popHostContainer, popHostContext = hostContext.popHostContext, resetHostContainer = hostContext.resetHostContainer, _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext), beginWork = _ReactFiberBeginWork.beginWork, beginFailedWork = _ReactFiberBeginWork.beginFailedWork, _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, hydrationContext), completeWork = _ReactFiberCompleteWo.completeWork, _ReactFiberCommitWork = ReactFiberCommitWork(config, captureError), commitPlacement = _ReactFiberCommitWork.commitPlacement, commitDeletion = _ReactFiberCommitWork.commitDeletion, commitWork = _ReactFiberCommitWork.commitWork, commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles, commitAttachRef = _ReactFiberCommitWork.commitAttachRef, commitDetachRef = _ReactFiberCommitWork.commitDetachRef, scheduleDeferredCallback = config.scheduleDeferredCallback, useSyncScheduling = config.useSyncScheduling, prepareForCommit = config.prepareForCommit, resetAfterCommit = config.resetAfterCommit, priorityContext = NoWork$2, priorityContextBeforeReconciliation = NoWork$2, isPerformingWork = !1, deadlineHasExpired = !1, isBatchingUpdates = !1, isUnbatchingUpdates = !1, nextUnitOfWork = null, nextPriorityLevel = NoWork$2, nextEffect = null, pendingCommit = null, nextScheduledRoot = null, lastScheduledRoot = null, isCallbackScheduled = !1, capturedErrors = null, failedBoundaries = null, commitPhaseBoundaries = null, firstUncaughtError = null, fatalError = null, isCommitting = !1, isUnmounting = !1;
-    function resetContextStack() {
-        reset$1(), resetContext$1(), resetHostContainer();
-    }
-    function findNextUnitOfWork() {
-        for (;null !== nextScheduledRoot && nextScheduledRoot.current.pendingWorkPriority === NoWork$2; ) {
-            nextScheduledRoot.isScheduled = !1;
-            var next = nextScheduledRoot.nextScheduledRoot;
-            if (nextScheduledRoot.nextScheduledRoot = null, nextScheduledRoot === lastScheduledRoot) return nextScheduledRoot = null, 
-            lastScheduledRoot = null, nextPriorityLevel = NoWork$2, null;
-            nextScheduledRoot = next;
-        }
-        for (var root = nextScheduledRoot, highestPriorityRoot = null, highestPriorityLevel = NoWork$2; null !== root; ) root.current.pendingWorkPriority !== NoWork$2 && (highestPriorityLevel === NoWork$2 || highestPriorityLevel > root.current.pendingWorkPriority) && (highestPriorityLevel = root.current.pendingWorkPriority, 
-        highestPriorityRoot = root), root = root.nextScheduledRoot;
-        return null !== highestPriorityRoot ? (nextPriorityLevel = highestPriorityLevel, 
-        priorityContext = nextPriorityLevel, resetContextStack(), createWorkInProgress$1(highestPriorityRoot.current, highestPriorityLevel)) : (nextPriorityLevel = NoWork$2, 
-        null);
-    }
-    function commitAllHostEffects() {
-        for (;null !== nextEffect; ) {
-            ReactDebugCurrentFiber$3.current = nextEffect, recordEffect();
-            var effectTag = nextEffect.effectTag;
-            if (effectTag & ContentReset && config.resetTextContent(nextEffect.stateNode), effectTag & Ref) {
-                var current = nextEffect.alternate;
-                null !== current && commitDetachRef(current);
-            }
-            switch (effectTag & ~(Callback | Err | ContentReset | Ref | PerformedWork)) {
-              case Placement$1:
-                commitPlacement(nextEffect), nextEffect.effectTag &= ~Placement$1;
-                break;
-
-              case PlacementAndUpdate:
-                commitPlacement(nextEffect), nextEffect.effectTag &= ~Placement$1;
-                var _current = nextEffect.alternate;
-                commitWork(_current, nextEffect);
-                break;
-
-              case Update:
-                var _current2 = nextEffect.alternate;
-                commitWork(_current2, nextEffect);
-                break;
-
-              case Deletion:
-                isUnmounting = !0, commitDeletion(nextEffect), isUnmounting = !1;
-            }
-            nextEffect = nextEffect.nextEffect;
-        }
-        ReactDebugCurrentFiber$3.current = null;
-    }
-    function commitAllLifeCycles() {
-        for (;null !== nextEffect; ) {
-            var effectTag = nextEffect.effectTag;
-            if (effectTag & (Update | Callback)) {
-                recordEffect();
-                var current = nextEffect.alternate;
-                commitLifeCycles(current, nextEffect);
-            }
-            effectTag & Ref && (recordEffect(), commitAttachRef(nextEffect)), effectTag & Err && (recordEffect(), 
-            commitErrorHandling(nextEffect));
-            var next = nextEffect.nextEffect;
-            nextEffect.nextEffect = null, nextEffect = next;
-        }
-    }
-    function commitAllWork(finishedWork) {
-        isCommitting = !0, startCommitTimer(), pendingCommit = null;
-        var root = finishedWork.stateNode;
-        invariant(root.current !== finishedWork, "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."), 
-        ReactCurrentOwner$1.current = null;
-        var previousPriorityContext = priorityContext;
-        priorityContext = TaskPriority$1;
-        var firstEffect = void 0;
-        for (finishedWork.effectTag > PerformedWork ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, 
-        firstEffect = finishedWork.firstEffect) : firstEffect = finishedWork : firstEffect = finishedWork.firstEffect, 
-        prepareForCommit(), nextEffect = firstEffect, startCommitHostEffectsTimer(); null !== nextEffect; ) {
-            var _error = null;
-            _error = invokeGuardedCallback$1(null, commitAllHostEffects, null), null !== _error && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
-            captureError(nextEffect, _error), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
-        }
-        for (stopCommitHostEffectsTimer(), resetAfterCommit(), root.current = finishedWork, 
-        nextEffect = firstEffect, startCommitLifeCyclesTimer(); null !== nextEffect; ) {
-            var _error2 = null;
-            _error2 = invokeGuardedCallback$1(null, commitAllLifeCycles, null), null !== _error2 && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
-            captureError(nextEffect, _error2), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
-        }
-        isCommitting = !1, stopCommitLifeCyclesTimer(), stopCommitTimer(), "function" == typeof onCommitRoot && onCommitRoot(finishedWork.stateNode), 
-        !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCommitWork(finishedWork), 
-        commitPhaseBoundaries && (commitPhaseBoundaries.forEach(scheduleErrorRecovery), 
-        commitPhaseBoundaries = null), priorityContext = previousPriorityContext;
-    }
-    function resetWorkPriority(workInProgress, renderPriority) {
-        if (!(workInProgress.pendingWorkPriority !== NoWork$2 && workInProgress.pendingWorkPriority > renderPriority)) {
-            for (var newPriority = getUpdatePriority$1(workInProgress), child = workInProgress.child; null !== child; ) newPriority = largerPriority$1(newPriority, child.pendingWorkPriority), 
-            child = child.sibling;
-            workInProgress.pendingWorkPriority = newPriority;
-        }
-    }
-    function completeUnitOfWork(workInProgress) {
-        for (;!0; ) {
-            var current = workInProgress.alternate, next = completeWork(current, workInProgress, nextPriorityLevel), returnFiber = workInProgress.return, siblingFiber = workInProgress.sibling;
-            if (resetWorkPriority(workInProgress, nextPriorityLevel), null !== next) return stopWorkTimer(workInProgress), 
-            !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCompleteWork(workInProgress), 
-            next;
-            if (null !== returnFiber) {
-                null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress.firstEffect), 
-                null !== workInProgress.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect), 
-                returnFiber.lastEffect = workInProgress.lastEffect);
-                workInProgress.effectTag > PerformedWork && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress : returnFiber.firstEffect = workInProgress, 
-                returnFiber.lastEffect = workInProgress);
-            }
-            if (stopWorkTimer(workInProgress), !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCompleteWork(workInProgress), 
-            null !== siblingFiber) return siblingFiber;
-            if (null === returnFiber) return nextPriorityLevel < HighPriority ? commitAllWork(workInProgress) : pendingCommit = workInProgress, 
-            null;
-            workInProgress = returnFiber;
-        }
-        return null;
-    }
-    function performUnitOfWork(workInProgress) {
-        var current = workInProgress.alternate;
-        startWorkTimer(workInProgress);
-        var next = beginWork(current, workInProgress, nextPriorityLevel);
-        return !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onBeginWork(workInProgress), 
-        null === next && (next = completeUnitOfWork(workInProgress)), ReactCurrentOwner$1.current = null, 
-        ReactDebugCurrentFiber$3.current = null, next;
-    }
-    function performFailedUnitOfWork(workInProgress) {
-        var current = workInProgress.alternate;
-        startWorkTimer(workInProgress);
-        var next = beginFailedWork(current, workInProgress, nextPriorityLevel);
-        return !0 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onBeginWork(workInProgress), 
-        null === next && (next = completeUnitOfWork(workInProgress)), ReactCurrentOwner$1.current = null, 
-        ReactDebugCurrentFiber$3.current = null, next;
-    }
-    function clearErrors() {
-        for (null === nextUnitOfWork && (nextUnitOfWork = findNextUnitOfWork()); null !== capturedErrors && capturedErrors.size && null !== nextUnitOfWork && nextPriorityLevel !== NoWork$2 && nextPriorityLevel <= TaskPriority$1; ) null === (nextUnitOfWork = hasCapturedError(nextUnitOfWork) ? performFailedUnitOfWork(nextUnitOfWork) : performUnitOfWork(nextUnitOfWork)) && (nextUnitOfWork = findNextUnitOfWork());
-    }
-    function workLoopAsync(minPriorityLevel, deadline) {
-        for (;null !== nextUnitOfWork && !deadlineHasExpired; ) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
-            if (null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && null !== pendingCommit) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
-                if (commitAllWork(pendingCommit), nextUnitOfWork = findNextUnitOfWork(), clearErrors(), 
-                nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel < HighPriority) break;
-            } else deadlineHasExpired = !0;
-        } else deadlineHasExpired = !0;
-    }
-    function workLoopSync(minPriorityLevel) {
-        for (;null !== nextUnitOfWork && !(null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && (nextUnitOfWork = findNextUnitOfWork(), 
-        clearErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel > TaskPriority$1)); ) ;
-    }
-    function workLoop(minPriorityLevel, deadline) {
-        clearErrors(), null === nextUnitOfWork && (nextUnitOfWork = findNextUnitOfWork()), 
-        nextPriorityLevel !== NoWork$2 && nextPriorityLevel <= minPriorityLevel && (nextPriorityLevel <= TaskPriority$1 ? workLoopSync(minPriorityLevel) : null !== deadline && workLoopAsync(minPriorityLevel, deadline));
-    }
-    function performDeferredWork(deadline) {
-        performWork(OffscreenPriority, deadline);
-    }
-    function performWork(minPriorityLevel, deadline) {
-        startWorkLoopTimer(), invariant(!isPerformingWork, "performWork was called recursively. This error is likely caused " + "by a bug in React. Please file an issue."), 
-        isPerformingWork = !0;
-        for (var hasRemainingAsyncWork = !1; null === fatalError; ) {
-            null === pendingCommit || deadlineHasExpired || commitAllWork(pendingCommit), priorityContextBeforeReconciliation = priorityContext;
-            var _error3 = null;
-            if (_error3 = invokeGuardedCallback$1(null, workLoop, null, minPriorityLevel, deadline), 
-            priorityContext = priorityContextBeforeReconciliation, null === _error3) {
-                switch (nextPriorityLevel) {
-                  case SynchronousPriority$1:
-                  case TaskPriority$1:
-                    if (nextPriorityLevel <= minPriorityLevel) continue;
-                    break;
-
-                  case HighPriority:
-                  case LowPriority:
-                  case OffscreenPriority:
-                    if (null === deadline) hasRemainingAsyncWork = !0; else {
-                        if (!deadlineHasExpired && nextPriorityLevel <= minPriorityLevel) continue;
-                        hasRemainingAsyncWork = !0;
-                    }
-                    break;
-
-                  case NoWork$2:
-                    break;
-
-                  default:
-                    invariant(!1, "Switch statement should be exhuastive.");
-                }
-                break;
-            }
-            var failedWork = nextUnitOfWork;
-            if (null === failedWork) null === fatalError && (fatalError = _error3); else {
-                var maybeBoundary = captureError(failedWork, _error3);
-                if (null !== maybeBoundary) {
-                    var boundary = maybeBoundary;
-                    beginFailedWork(boundary.alternate, boundary, nextPriorityLevel), unwindContexts(failedWork, boundary), 
-                    nextUnitOfWork = completeUnitOfWork(boundary);
-                }
-            }
-        }
-        null !== deadline && (isCallbackScheduled = !1), hasRemainingAsyncWork && !isCallbackScheduled && (scheduleDeferredCallback(performDeferredWork), 
-        isCallbackScheduled = !0);
-        var errorToThrow = null !== fatalError ? fatalError : firstUncaughtError;
-        if (isPerformingWork = !1, deadlineHasExpired = !1, fatalError = null, firstUncaughtError = null, 
-        capturedErrors = null, failedBoundaries = null, stopWorkLoopTimer(), null !== errorToThrow) throw errorToThrow;
-    }
-    function captureError(failedWork, error) {
-        ReactCurrentOwner$1.current = null, ReactDebugCurrentFiber$3.current = null, ReactDebugCurrentFiber$3.phase = null, 
-        nextUnitOfWork = null;
-        var boundary = null, errorBoundaryFound = !1, willRetry = !1, errorBoundaryName = null;
-        if (failedWork.tag === HostRoot$5) boundary = failedWork, isFailedBoundary(failedWork) && (fatalError = error); else for (var node = failedWork.return; null !== node && null === boundary; ) {
-            if (node.tag === ClassComponent$5) {
-                var instance = node.stateNode;
-                "function" == typeof instance.unstable_handleError && (errorBoundaryFound = !0, 
-                errorBoundaryName = getComponentName_1(node), boundary = node, willRetry = !0);
-            } else node.tag === HostRoot$5 && (boundary = node);
-            if (isFailedBoundary(node)) {
-                if (isUnmounting) return null;
-                if (null !== commitPhaseBoundaries && (commitPhaseBoundaries.has(node) || null !== node.alternate && commitPhaseBoundaries.has(node.alternate))) return null;
-                boundary = null, willRetry = !1;
-            }
-            node = node.return;
-        }
-        if (null !== boundary) {
-            null === failedBoundaries && (failedBoundaries = new Set()), failedBoundaries.add(boundary);
-            var _componentStack = getStackAddendumByWorkInProgressFiber$2(failedWork), _componentName = getComponentName_1(failedWork);
-            return null === capturedErrors && (capturedErrors = new Map()), capturedErrors.set(boundary, {
-                componentName: _componentName,
-                componentStack: _componentStack,
-                error: error,
-                errorBoundary: errorBoundaryFound ? boundary.stateNode : null,
-                errorBoundaryFound: errorBoundaryFound,
-                errorBoundaryName: errorBoundaryName,
-                willRetry: willRetry
-            }), isCommitting ? (null === commitPhaseBoundaries && (commitPhaseBoundaries = new Set()), 
-            commitPhaseBoundaries.add(boundary)) : scheduleErrorRecovery(boundary), boundary;
-        }
-        return null === firstUncaughtError && (firstUncaughtError = error), null;
-    }
-    function hasCapturedError(fiber) {
-        return null !== capturedErrors && (capturedErrors.has(fiber) || null !== fiber.alternate && capturedErrors.has(fiber.alternate));
-    }
-    function isFailedBoundary(fiber) {
-        return null !== failedBoundaries && (failedBoundaries.has(fiber) || null !== fiber.alternate && failedBoundaries.has(fiber.alternate));
-    }
-    function commitErrorHandling(effectfulFiber) {
-        var capturedError = void 0;
-        null !== capturedErrors && (capturedError = capturedErrors.get(effectfulFiber), 
-        capturedErrors.delete(effectfulFiber), null == capturedError && null !== effectfulFiber.alternate && (effectfulFiber = effectfulFiber.alternate, 
-        capturedError = capturedErrors.get(effectfulFiber), capturedErrors.delete(effectfulFiber))), 
-        invariant(null != capturedError, "No error for given unit of work. This error is likely caused by a " + "bug in React. Please file an issue.");
-        var error = capturedError.error;
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var ReactNativeFeatureFlags$1 = require("ReactNativeFeatureFlags"), mountSafeCallback$2 = NativeMethodsMixinUtils.mountSafeCallback, findNumericNodeHandle = ReactNativeFeatureFlags$1.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim, ReactNativeComponent = function(_React$Component) {
+        _inherits(ReactNativeComponent, _React$Component);
+        function ReactNativeComponent() {
+            return _classCallCheck$2(this, ReactNativeComponent), _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
+        }
+        return ReactNativeComponent.prototype.blur = function() {
+            TextInputState.blurTextInput(findNumericNodeHandle(this));
+        }, ReactNativeComponent.prototype.focus = function() {
+            TextInputState.focusTextInput(findNumericNodeHandle(this));
+        }, ReactNativeComponent.prototype.measure = function(callback) {
+            UIManager.measure(findNumericNodeHandle(this), mountSafeCallback$2(this, callback));
+        }, ReactNativeComponent.prototype.measureInWindow = function(callback) {
+            UIManager.measureInWindow(findNumericNodeHandle(this), mountSafeCallback$2(this, callback));
+        }, ReactNativeComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
+            UIManager.measureLayout(findNumericNodeHandle(this), relativeToNativeNode, mountSafeCallback$2(this, onFail), mountSafeCallback$2(this, onSuccess));
+        }, ReactNativeComponent.prototype.setNativeProps = function(nativeProps) {
+            injectedSetNativeProps(this, nativeProps);
+        }, ReactNativeComponent;
+    }(react.Component);
+    function setNativePropsFiber(componentOrHandle, nativeProps) {
+        var maybeInstance = void 0;
         try {
-            logCapturedError$1(capturedError);
+            maybeInstance = findNodeHandle_1(componentOrHandle);
+        } catch (error) {}
+        if (null != maybeInstance) {
+            var viewConfig = maybeInstance.viewConfig, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    function setNativePropsStack(componentOrHandle, nativeProps) {
+        var maybeInstance = findNodeHandle_1(componentOrHandle);
+        if (null != maybeInstance) {
+            var viewConfig = void 0;
+            if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
+                for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
+                viewConfig = maybeInstance.viewConfig;
+            }
+            var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    var injectedSetNativeProps = void 0;
+    injectedSetNativeProps = ReactNativeFeatureFlags$1.useFiber ? setNativePropsFiber : setNativePropsStack;
+    var ReactNativeComponent_1 = ReactNativeComponent, ReactNativeFeatureFlags$2 = require("ReactNativeFeatureFlags"), mountSafeCallback$3 = NativeMethodsMixinUtils.mountSafeCallback, throwOnStylesProp$1 = NativeMethodsMixinUtils.throwOnStylesProp, warnForStyleProps$2 = NativeMethodsMixinUtils.warnForStyleProps, findNumericNodeHandle$1 = ReactNativeFeatureFlags$2.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim, NativeMethodsMixin = {
+        measure: function(callback) {
+            UIManager.measure(findNumericNodeHandle$1(this), mountSafeCallback$3(this, callback));
+        },
+        measureInWindow: function(callback) {
+            UIManager.measureInWindow(findNumericNodeHandle$1(this), mountSafeCallback$3(this, callback));
+        },
+        measureLayout: function(relativeToNativeNode, onSuccess, onFail) {
+            UIManager.measureLayout(findNumericNodeHandle$1(this), relativeToNativeNode, mountSafeCallback$3(this, onFail), mountSafeCallback$3(this, onSuccess));
+        },
+        setNativeProps: function(nativeProps) {
+            injectedSetNativeProps$1(this, nativeProps);
+        },
+        focus: function() {
+            TextInputState.focusTextInput(findNumericNodeHandle$1(this));
+        },
+        blur: function() {
+            TextInputState.blurTextInput(findNumericNodeHandle$1(this));
+        }
+    };
+    function setNativePropsFiber$1(componentOrHandle, nativeProps) {
+        var maybeInstance = void 0;
+        try {
+            maybeInstance = findNodeHandle_1(componentOrHandle);
+        } catch (error) {}
+        if (null != maybeInstance) {
+            var viewConfig = maybeInstance.viewConfig;
+            warnForStyleProps$2(nativeProps, viewConfig.validAttributes);
+            var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    function setNativePropsStack$1(componentOrHandle, nativeProps) {
+        var maybeInstance = findNodeHandle_1(componentOrHandle);
+        if (null != maybeInstance) {
+            var viewConfig = void 0;
+            if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
+                for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
+                viewConfig = maybeInstance.viewConfig;
+            }
+            var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID;
+            warnForStyleProps$2(nativeProps, viewConfig.validAttributes);
+            var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    var injectedSetNativeProps$1 = void 0;
+    injectedSetNativeProps$1 = ReactNativeFeatureFlags$2.useFiber ? setNativePropsFiber$1 : setNativePropsStack$1;
+    var NativeMethodsMixin_DEV = NativeMethodsMixin;
+    invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps, "Do not override existing functions."), 
+    NativeMethodsMixin_DEV.componentWillMount = function() {
+        throwOnStylesProp$1(this, this.props);
+    }, NativeMethodsMixin_DEV.componentWillReceiveProps = function(newProps) {
+        throwOnStylesProp$1(this, newProps);
+    };
+    var NativeMethodsMixin_1 = NativeMethodsMixin, TouchHistoryMath = {
+        centroidDimension: function(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+            var touchBank = touchHistory.touchBank, total = 0, count = 0, oneTouchData = 1 === touchHistory.numberActiveTouches ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+            if (null !== oneTouchData) oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter && (total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY, 
+            count = 1); else for (var i = 0; i < touchBank.length; i++) {
+                var touchTrack = touchBank[i];
+                if (null !== touchTrack && void 0 !== touchTrack && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+                    var toAdd;
+                    toAdd = ofCurrent && isXAxis ? touchTrack.currentPageX : ofCurrent && !isXAxis ? touchTrack.currentPageY : !ofCurrent && isXAxis ? touchTrack.previousPageX : touchTrack.previousPageY, 
+                    total += toAdd, count++;
+                }
+            }
+            return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+        },
+        currentCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !0);
+        },
+        currentCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !0);
+        },
+        previousCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !1);
+        },
+        previousCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !1);
+        },
+        currentCentroidX: function(touchHistory) {
+            return TouchHistoryMath.centroidDimension(touchHistory, 0, !0, !0);
+        },
+        currentCentroidY: function(touchHistory) {
+            return TouchHistoryMath.centroidDimension(touchHistory, 0, !1, !0);
+        },
+        noCentroid: -1
+    }, TouchHistoryMath_1 = TouchHistoryMath, createReactNativeComponentClassFiber = function(viewConfig) {
+        return ReactNativeViewConfigRegistry_1.register(viewConfig);
+    }, createReactNativeComponentClassFiber_1 = createReactNativeComponentClassFiber, ReactNativeFeatureFlags$3 = require("ReactNativeFeatureFlags"), createReactNativeComponentClass = ReactNativeFeatureFlags$3.useFiber ? createReactNativeComponentClassFiber_1 : DevOnlyStubShim, ReactNativeFeatureFlags$4 = require("ReactNativeFeatureFlags"), findNumericNodeHandle$2 = ReactNativeFeatureFlags$4.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim;
+    function takeSnapshot(view, options) {
+        return "number" != typeof view && "window" !== view && (view = findNumericNodeHandle$2(view) || "window"), 
+        UIManager.__takeSnapshot(view, options);
+    }
+    var takeSnapshot_1 = takeSnapshot, ReactInvalidSetStateWarningHook = {}, warning$15 = require$$0, processingChildContext = !1, warnInvalidSetState = function() {
+        warning$15(!processingChildContext, "setState(...): Cannot call setState() inside getChildContext()");
+    };
+    ReactInvalidSetStateWarningHook = {
+        onBeginProcessingChildContext: function() {
+            processingChildContext = !0;
+        },
+        onEndProcessingChildContext: function() {
+            processingChildContext = !1;
+        },
+        onSetState: function() {
+            warnInvalidSetState();
+        }
+    };
+    var ReactInvalidSetStateWarningHook_1 = ReactInvalidSetStateWarningHook, ReactHostOperationHistoryHook = null, history = [];
+    ReactHostOperationHistoryHook = {
+        onHostOperation: function(operation) {
+            history.push(operation);
+        },
+        clearHistory: function() {
+            ReactHostOperationHistoryHook._preventClearing || (history = []);
+        },
+        getHistory: function() {
+            return history;
+        }
+    };
+    var ReactHostOperationHistoryHook_1 = ReactHostOperationHistoryHook, ReactComponentTreeHook = ReactGlobalSharedState_1.ReactComponentTreeHook, warning$14 = require$$0, ReactDebugTool = null, hooks = [], didHookThrowForEvent = {}, callHook = function(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
+        try {
+            fn.call(context, arg1, arg2, arg3, arg4, arg5);
         } catch (e) {
-            console.error(e);
+            warning$14(didHookThrowForEvent[event], "Exception thrown by hook while handling %s: %s", event, e + "\n" + e.stack), 
+            didHookThrowForEvent[event] = !0;
         }
-        switch (effectfulFiber.tag) {
-          case ClassComponent$5:
-            var instance = effectfulFiber.stateNode, info = {
-                componentStack: capturedError.componentStack
-            };
-            return void instance.unstable_handleError(error, info);
-
-          case HostRoot$5:
-            return void (null === firstUncaughtError && (firstUncaughtError = error));
-
-          default:
-            invariant(!1, "Invalid type of work. This error is likely caused by a bug in " + "React. Please file an issue.");
+    }, emitEvent = function(event, arg1, arg2, arg3, arg4, arg5) {
+        for (var i = 0; i < hooks.length; i++) {
+            var hook = hooks[i], fn = hook[event];
+            fn && callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
         }
-    }
-    function unwindContexts(from, to) {
-        for (var node = from; null !== node && node !== to && node.alternate !== to; ) {
-            switch (node.tag) {
-              case ClassComponent$5:
-                popContextProvider$1(node);
-                break;
-
-              case HostComponent$6:
-                popHostContext(node);
-                break;
-
-              case HostRoot$5:
-              case HostPortal$2:
-                popHostContainer(node);
-            }
-            stopWorkTimer(node), node = node.return;
-        }
-    }
-    function scheduleRoot(root, priorityLevel) {
-        priorityLevel !== NoWork$2 && (root.isScheduled || (root.isScheduled = !0, lastScheduledRoot ? (lastScheduledRoot.nextScheduledRoot = root, 
-        lastScheduledRoot = root) : (nextScheduledRoot = root, lastScheduledRoot = root)));
-    }
-    function scheduleUpdate(fiber, priorityLevel) {
-        if (recordScheduleUpdate(), priorityLevel <= nextPriorityLevel && (nextUnitOfWork = null), 
-        fiber.tag === ClassComponent$5) {
-            var instance = fiber.stateNode;
-            warnAboutInvalidUpdates(instance);
-        }
-        for (var node = fiber, shouldContinue = !0; null !== node && shouldContinue; ) {
-            if (shouldContinue = !1, (node.pendingWorkPriority === NoWork$2 || node.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
-            node.pendingWorkPriority = priorityLevel), null !== node.alternate && (node.alternate.pendingWorkPriority === NoWork$2 || node.alternate.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
-            node.alternate.pendingWorkPriority = priorityLevel), null === node.return) {
-                if (node.tag !== HostRoot$5) return void (fiber.tag === ClassComponent$5 && warnAboutUpdateOnUnmounted(fiber.stateNode));
-                if (scheduleRoot(node.stateNode, priorityLevel), !isPerformingWork) switch (priorityLevel) {
-                  case SynchronousPriority$1:
-                    isUnbatchingUpdates ? performWork(SynchronousPriority$1, null) : performWork(TaskPriority$1, null);
-                    break;
-
-                  case TaskPriority$1:
-                    invariant(isBatchingUpdates, "Task updates can only be scheduled as a nested update or " + "inside batchedUpdates.");
-                    break;
-
-                  default:
-                    isCallbackScheduled || (scheduleDeferredCallback(performDeferredWork), isCallbackScheduled = !0);
-                }
-            }
-            node = node.return;
-        }
-    }
-    function getPriorityContext(fiber, forceAsync) {
-        var priorityLevel = priorityContext;
-        return priorityLevel === NoWork$2 && (priorityLevel = !useSyncScheduling || fiber.internalContextTag & AsyncUpdates || forceAsync ? LowPriority : SynchronousPriority$1), 
-        priorityLevel === SynchronousPriority$1 && (isPerformingWork || isBatchingUpdates) ? TaskPriority$1 : priorityLevel;
-    }
-    function scheduleErrorRecovery(fiber) {
-        scheduleUpdate(fiber, TaskPriority$1);
-    }
-    function performWithPriority(priorityLevel, fn) {
-        var previousPriorityContext = priorityContext;
-        priorityContext = priorityLevel;
-        try {
-            fn();
-        } finally {
-            priorityContext = previousPriorityContext;
-        }
-    }
-    function batchedUpdates(fn, a) {
-        var previousIsBatchingUpdates = isBatchingUpdates;
-        isBatchingUpdates = !0;
-        try {
-            return fn(a);
-        } finally {
-            isBatchingUpdates = previousIsBatchingUpdates, isPerformingWork || isBatchingUpdates || performWork(TaskPriority$1, null);
-        }
-    }
-    function unbatchedUpdates(fn) {
-        var previousIsUnbatchingUpdates = isUnbatchingUpdates, previousIsBatchingUpdates = isBatchingUpdates;
-        isUnbatchingUpdates = isBatchingUpdates, isBatchingUpdates = !1;
-        try {
-            return fn();
-        } finally {
-            isBatchingUpdates = previousIsBatchingUpdates, isUnbatchingUpdates = previousIsUnbatchingUpdates;
-        }
-    }
-    function syncUpdates(fn) {
-        var previousPriorityContext = priorityContext;
-        priorityContext = SynchronousPriority$1;
-        try {
-            return fn();
-        } finally {
-            priorityContext = previousPriorityContext;
-        }
-    }
-    function deferredUpdates(fn) {
-        var previousPriorityContext = priorityContext;
-        priorityContext = LowPriority;
-        try {
-            return fn();
-        } finally {
-            priorityContext = previousPriorityContext;
-        }
-    }
-    return {
-        scheduleUpdate: scheduleUpdate,
-        getPriorityContext: getPriorityContext,
-        performWithPriority: performWithPriority,
-        batchedUpdates: batchedUpdates,
-        unbatchedUpdates: unbatchedUpdates,
-        syncUpdates: syncUpdates,
-        deferredUpdates: deferredUpdates
-    };
-}, getContextFiber = function(arg) {
-    invariant(!1, "Missing injection for fiber getContextForSubtree");
-};
-
-function getContextForSubtree(parentComponent) {
-    if (!parentComponent) return emptyObject;
-    var instance = ReactInstanceMap_1.get(parentComponent);
-    return "number" == typeof instance.tag ? getContextFiber(instance) : instance._processChildContext(instance._context);
-}
-
-getContextForSubtree._injectFiber = function(fn) {
-    getContextFiber = fn;
-};
-
-var getContextForSubtree_1 = getContextForSubtree, addTopLevelUpdate = ReactFiberUpdateQueue.addTopLevelUpdate, findCurrentUnmaskedContext = ReactFiberContext.findCurrentUnmaskedContext, isContextProvider = ReactFiberContext.isContextProvider, processChildContext = ReactFiberContext.processChildContext, createFiberRoot = ReactFiberRoot.createFiberRoot, HostComponent$1 = ReactTypeOfWork.HostComponent, warning$2 = warning, ReactFiberInstrumentation = ReactFiberInstrumentation_1, ReactDebugCurrentFiber = ReactDebugCurrentFiber_1, getComponentName = getComponentName_1, findCurrentHostFiber = ReactFiberTreeReflection.findCurrentHostFiber;
-
-getContextForSubtree_1._injectFiber(function(fiber) {
-    var parentContext = findCurrentUnmaskedContext(fiber);
-    return isContextProvider(fiber) ? processChildContext(fiber, parentContext, !1) : parentContext;
-});
-
-var ReactFiberReconciler = function(config) {
-    var getPublicInstance = config.getPublicInstance, _ReactFiberScheduler = ReactFiberScheduler(config), scheduleUpdate = _ReactFiberScheduler.scheduleUpdate, getPriorityContext = _ReactFiberScheduler.getPriorityContext, performWithPriority = _ReactFiberScheduler.performWithPriority, batchedUpdates = _ReactFiberScheduler.batchedUpdates, unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates, syncUpdates = _ReactFiberScheduler.syncUpdates, deferredUpdates = _ReactFiberScheduler.deferredUpdates;
-    function scheduleTopLevelUpdate(current, element, callback) {
-        "render" === ReactDebugCurrentFiber.phase && null !== ReactDebugCurrentFiber.current && warning$2(!1, "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");
-        var forceAsync = ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != element && null != element.type && !0 === element.type.unstable_asyncUpdates, priorityLevel = getPriorityContext(current, forceAsync), nextState = {
-            element: element
-        };
-        callback = void 0 === callback ? null : callback, warning$2(null === callback || "function" == typeof callback, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback), 
-        addTopLevelUpdate(current, nextState, callback, priorityLevel), scheduleUpdate(current, priorityLevel);
-    }
-    return {
-        createContainer: function(containerInfo) {
-            return createFiberRoot(containerInfo);
-        },
-        updateContainer: function(element, container, parentComponent, callback) {
-            var current = container.current;
-            ReactFiberInstrumentation.debugTool && (null === current.alternate ? ReactFiberInstrumentation.debugTool.onMountContainer(container) : null === element ? ReactFiberInstrumentation.debugTool.onUnmountContainer(container) : ReactFiberInstrumentation.debugTool.onUpdateContainer(container));
-            var context = getContextForSubtree_1(parentComponent);
-            null === container.context ? container.context = context : container.pendingContext = context, 
-            scheduleTopLevelUpdate(current, element, callback);
-        },
-        performWithPriority: performWithPriority,
-        batchedUpdates: batchedUpdates,
-        unbatchedUpdates: unbatchedUpdates,
-        syncUpdates: syncUpdates,
-        deferredUpdates: deferredUpdates,
-        getPublicRootInstance: function(container) {
-            var containerFiber = container.current;
-            if (!containerFiber.child) return null;
-            switch (containerFiber.child.tag) {
-              case HostComponent$1:
-                return getPublicInstance(containerFiber.child.stateNode);
-
-              default:
-                return containerFiber.child.stateNode;
-            }
-        },
-        findHostInstance: function(fiber) {
-            var hostFiber = findCurrentHostFiber(fiber);
-            return null === hostFiber ? null : hostFiber.stateNode;
-        }
-    };
-};
-
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-var objects = {}, uniqueID = 1, emptyObject$3 = {}, ReactNativePropRegistry = function() {
-    function ReactNativePropRegistry() {
-        _classCallCheck(this, ReactNativePropRegistry);
-    }
-    return ReactNativePropRegistry.register = function(object) {
-        var id = ++uniqueID;
-        return Object.freeze(object), objects[id] = object, id;
-    }, ReactNativePropRegistry.getByID = function(id) {
-        if (!id) return emptyObject$3;
-        var object = objects[id];
-        return object || (console.warn("Invalid style with id `" + id + "`. Skipping ..."), 
-        emptyObject$3);
-    }, ReactNativePropRegistry;
-}(), ReactNativePropRegistry_1 = ReactNativePropRegistry, emptyObject$2 = {}, removedKeys = null, removedKeyCount = 0;
-
-function defaultDiffer(prevProp, nextProp) {
-    return "object" != typeof nextProp || null === nextProp || deepDiffer(prevProp, nextProp);
-}
-
-function resolveObject(idOrObject) {
-    return "number" == typeof idOrObject ? ReactNativePropRegistry_1.getByID(idOrObject) : idOrObject;
-}
-
-function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
-    if (Array.isArray(node)) for (var i = node.length; i-- && removedKeyCount > 0; ) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes); else if (node && removedKeyCount > 0) {
-        var obj = resolveObject(node);
-        for (var propKey in removedKeys) if (removedKeys[propKey]) {
-            var nextProp = obj[propKey];
-            if (void 0 !== nextProp) {
-                var attributeConfig = validAttributes[propKey];
-                if (attributeConfig) {
-                    if ("function" == typeof nextProp && (nextProp = !0), void 0 === nextProp && (nextProp = null), 
-                    "object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-                        var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
-                        updatePayload[propKey] = nextValue;
-                    }
-                    removedKeys[propKey] = !1, removedKeyCount--;
-                }
-            }
-        }
-    }
-}
-
-function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
-    var i, minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
-    for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
-    for (;i < prevArray.length; i++) updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
-    for (;i < nextArray.length; i++) updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
-    return updatePayload;
-}
-
-function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
-    return updatePayload || prevProp !== nextProp ? prevProp && nextProp ? Array.isArray(prevProp) || Array.isArray(nextProp) ? Array.isArray(prevProp) && Array.isArray(nextProp) ? diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes) : Array.isArray(prevProp) ? diffProperties(updatePayload, flattenStyle(prevProp), resolveObject(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), flattenStyle(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), resolveObject(nextProp), validAttributes) : nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload : updatePayload;
-}
-
-function addNestedProperty(updatePayload, nextProp, validAttributes) {
-    if (!nextProp) return updatePayload;
-    if (!Array.isArray(nextProp)) return addProperties(updatePayload, resolveObject(nextProp), validAttributes);
-    for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
-    return updatePayload;
-}
-
-function clearNestedProperty(updatePayload, prevProp, validAttributes) {
-    if (!prevProp) return updatePayload;
-    if (!Array.isArray(prevProp)) return clearProperties(updatePayload, resolveObject(prevProp), validAttributes);
-    for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
-    return updatePayload;
-}
-
-function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
-    var attributeConfig, nextProp, prevProp;
-    for (var propKey in nextProps) if (attributeConfig = validAttributes[propKey]) if (prevProp = prevProps[propKey], 
-    nextProp = nextProps[propKey], "function" == typeof nextProp && (nextProp = !0, 
-    "function" == typeof prevProp && (prevProp = !0)), void 0 === nextProp && (nextProp = null, 
-    void 0 === prevProp && (prevProp = null)), removedKeys && (removedKeys[propKey] = !1), 
-    updatePayload && void 0 !== updatePayload[propKey]) {
-        if ("object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-            var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
-            updatePayload[propKey] = nextValue;
-        }
-    } else if (prevProp !== nextProp) if ("object" != typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp); else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-        var shouldUpdate = void 0 === prevProp || ("function" == typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));
-        shouldUpdate && (nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, 
-        (updatePayload || (updatePayload = {}))[propKey] = nextValue);
-    } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 
-    removedKeyCount > 0 && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), 
-    removedKeys = null);
-    for (propKey in prevProps) void 0 === nextProps[propKey] && (attributeConfig = validAttributes[propKey]) && (updatePayload && void 0 !== updatePayload[propKey] || void 0 !== (prevProp = prevProps[propKey]) && ("object" != typeof attributeConfig || "function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey] = null, 
-    removedKeys || (removedKeys = {}), removedKeys[propKey] || (removedKeys[propKey] = !0, 
-    removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig)));
-    return updatePayload;
-}
-
-function addProperties(updatePayload, props, validAttributes) {
-    return diffProperties(updatePayload, emptyObject$2, props, validAttributes);
-}
-
-function clearProperties(updatePayload, prevProps, validAttributes) {
-    return diffProperties(updatePayload, prevProps, emptyObject$2, validAttributes);
-}
-
-var ReactNativeAttributePayload = {
-    create: function(props, validAttributes) {
-        return addProperties(null, props, validAttributes);
-    },
-    diff: function(prevProps, nextProps, validAttributes) {
-        return diffProperties(null, prevProps, nextProps, validAttributes);
-    }
-}, ReactNativeAttributePayload_1 = ReactNativeAttributePayload;
-
-function mountSafeCallback$1(context, callback) {
-    return function() {
-        if (callback) {
-            if ("boolean" == typeof context.__isMounted) {
-                if (!context.__isMounted) return;
-            } else if ("function" == typeof context.isMounted && !context.isMounted()) return;
-            return callback.apply(context, arguments);
-        }
-    };
-}
-
-function throwOnStylesProp(component, props) {
-    if (void 0 !== props.styles) {
-        var owner = component._owner || null, name = component.constructor.displayName, msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
-        throw owner && owner.constructor && owner.constructor.displayName && (msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component."), 
-        new Error(msg);
-    }
-}
-
-function warnForStyleProps$1(props, validAttributes) {
-    for (var key in validAttributes.style) validAttributes[key] || void 0 === props[key] || console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
-}
-
-var NativeMethodsMixinUtils = {
-    mountSafeCallback: mountSafeCallback$1,
-    throwOnStylesProp: throwOnStylesProp,
-    warnForStyleProps: warnForStyleProps$1
-};
-
-function _classCallCheck$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-var mountSafeCallback = NativeMethodsMixinUtils.mountSafeCallback, warnForStyleProps = NativeMethodsMixinUtils.warnForStyleProps, ReactNativeFiberHostComponent = function() {
-    function ReactNativeFiberHostComponent(tag, viewConfig) {
-        _classCallCheck$1(this, ReactNativeFiberHostComponent), this._nativeTag = tag, this._children = [], 
-        this.viewConfig = viewConfig;
-    }
-    return ReactNativeFiberHostComponent.prototype.blur = function() {
-        TextInputState.blurTextInput(this._nativeTag);
-    }, ReactNativeFiberHostComponent.prototype.focus = function() {
-        TextInputState.focusTextInput(this._nativeTag);
-    }, ReactNativeFiberHostComponent.prototype.measure = function(callback) {
-        UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
-    }, ReactNativeFiberHostComponent.prototype.measureInWindow = function(callback) {
-        UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
-    }, ReactNativeFiberHostComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
-        UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
-    }, ReactNativeFiberHostComponent.prototype.setNativeProps = function(nativeProps) {
-        warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
-        var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, this.viewConfig.validAttributes);
-        UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
-    }, ReactNativeFiberHostComponent;
-}(), ReactNativeFiberHostComponent_1 = ReactNativeFiberHostComponent, viewConfigs = new Map(), ReactNativeViewConfigRegistry = {
-    register: function(viewConfig) {
-        var name = viewConfig.uiViewClassName;
-        return invariant(!viewConfigs.has(name), "Tried to register two views with the same name %s", name), 
-        viewConfigs.set(name, viewConfig), name;
-    },
-    get: function(name) {
-        var config = viewConfigs.get(name);
-        return invariant(config, "View config not found for name %s", name), config;
-    }
-}, ReactNativeViewConfigRegistry_1 = ReactNativeViewConfigRegistry, precacheFiberNode$1 = ReactNativeComponentTree_1.precacheFiberNode, uncacheFiberNode$1 = ReactNativeComponentTree_1.uncacheFiberNode, updateFiberProps$1 = ReactNativeComponentTree_1.updateFiberProps;
-
-function recursivelyUncacheFiberNode(node) {
-    "number" == typeof node ? uncacheFiberNode$1(node) : (uncacheFiberNode$1(node._nativeTag), 
-    node._children.forEach(recursivelyUncacheFiberNode));
-}
-
-var NativeRenderer = ReactFiberReconciler({
-    appendChild: function(parentInstance, child) {
-        var childTag = "number" == typeof child ? child : child._nativeTag, children = parentInstance._children, index = children.indexOf(child);
-        index >= 0 ? (children.splice(index, 1), children.push(child), UIManager.manageChildren(parentInstance._nativeTag, [ index ], [ children.length - 1 ], [], [], [])) : (children.push(child), 
-        UIManager.manageChildren(parentInstance._nativeTag, [], [], [ childTag ], [ children.length - 1 ], []));
-    },
-    appendChildToContainer: function(parentInstance, child) {
-        var childTag = "number" == typeof child ? child : child._nativeTag;
-        UIManager.setChildren(parentInstance, [ childTag ]);
-    },
-    appendInitialChild: function(parentInstance, child) {
-        parentInstance._children.push(child);
-    },
-    commitTextUpdate: function(textInstance, oldText, newText) {
-        UIManager.updateView(textInstance, "RCTRawText", {
-            text: newText
-        });
-    },
-    commitMount: function(instance, type, newProps, internalInstanceHandle) {},
-    commitUpdate: function(instance, updatePayloadTODO, type, oldProps, newProps, internalInstanceHandle) {
-        var viewConfig = instance.viewConfig;
-        updateFiberProps$1(instance._nativeTag, newProps);
-        var updatePayload = ReactNativeAttributePayload_1.diff(oldProps, newProps, viewConfig.validAttributes);
-        UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
-    },
-    createInstance: function(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
-        var tag = ReactNativeTagHandles_1.allocateTag(), viewConfig = ReactNativeViewConfigRegistry_1.get(type);
-        for (var key in viewConfig.validAttributes) props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(props[key]);
-        var updatePayload = ReactNativeAttributePayload_1.create(props, viewConfig.validAttributes);
-        UIManager.createView(tag, viewConfig.uiViewClassName, rootContainerInstance, updatePayload);
-        var component = new ReactNativeFiberHostComponent_1(tag, viewConfig);
-        return precacheFiberNode$1(internalInstanceHandle, tag), updateFiberProps$1(tag, props), 
-        component;
-    },
-    createTextInstance: function(text, rootContainerInstance, hostContext, internalInstanceHandle) {
-        var tag = ReactNativeTagHandles_1.allocateTag();
-        return UIManager.createView(tag, "RCTRawText", rootContainerInstance, {
-            text: text
-        }), precacheFiberNode$1(internalInstanceHandle, tag), tag;
-    },
-    finalizeInitialChildren: function(parentInstance, type, props, rootContainerInstance) {
-        if (0 === parentInstance._children.length) return !1;
-        var nativeTags = parentInstance._children.map(function(child) {
-            return "number" == typeof child ? child : child._nativeTag;
-        });
-        return UIManager.setChildren(parentInstance._nativeTag, nativeTags), !1;
-    },
-    getRootHostContext: function() {
-        return emptyObject;
-    },
-    getChildHostContext: function() {
-        return emptyObject;
-    },
-    getPublicInstance: function(instance) {
-        return instance;
-    },
-    insertBefore: function(parentInstance, child, beforeChild) {
-        var children = parentInstance._children, index = children.indexOf(child);
-        if (index >= 0) {
-            children.splice(index, 1);
-            var beforeChildIndex = children.indexOf(beforeChild);
-            children.splice(beforeChildIndex, 0, child), UIManager.manageChildren(parentInstance._nativeTag, [ index ], [ beforeChildIndex ], [], [], []);
-        } else {
-            var _beforeChildIndex = children.indexOf(beforeChild);
-            children.splice(_beforeChildIndex, 0, child);
-            var childTag = "number" == typeof child ? child : child._nativeTag;
-            UIManager.manageChildren(parentInstance._nativeTag, [], [], [ childTag ], [ _beforeChildIndex ], []);
-        }
-    },
-    insertInContainerBefore: function(parentInstance, child, beforeChild) {
-        invariant("number" != typeof parentInstance, "Container does not support insertBefore operation");
-    },
-    prepareForCommit: function() {},
-    prepareUpdate: function(instance, type, oldProps, newProps, rootContainerInstance, hostContext) {
-        return emptyObject;
-    },
-    removeChild: function(parentInstance, child) {
-        recursivelyUncacheFiberNode(child);
-        var children = parentInstance._children, index = children.indexOf(child);
-        children.splice(index, 1), UIManager.manageChildren(parentInstance._nativeTag, [], [], [], [], [ index ]);
-    },
-    removeChildFromContainer: function(parentInstance, child) {
-        recursivelyUncacheFiberNode(child), UIManager.manageChildren(parentInstance, [], [], [], [], [ 0 ]);
-    },
-    resetAfterCommit: function() {},
-    resetTextContent: function(instance) {},
-    shouldDeprioritizeSubtree: function(type, props) {
-        return !1;
-    },
-    scheduleDeferredCallback: commonjsGlobal.requestIdleCallback,
-    shouldSetTextContent: function(type, props) {
-        return !1;
-    },
-    useSyncScheduling: !0
-}), ReactNativeFiberRenderer = NativeRenderer, getClosestInstanceFromNode = ReactNativeComponentTree_1.getClosestInstanceFromNode, findCurrentFiberUsingSlowPath$1 = ReactFiberTreeReflection.findCurrentFiberUsingSlowPath, HostComponent$11 = ReactTypeOfWork.HostComponent, getInspectorDataForViewTag = void 0, traverseOwnerTreeUp = function(hierarchy, instance) {
-    instance && (hierarchy.unshift(instance), traverseOwnerTreeUp(hierarchy, instance._debugOwner));
-}, getOwnerHierarchy = function(instance) {
-    var hierarchy = [];
-    return traverseOwnerTreeUp(hierarchy, instance), hierarchy;
-}, lastNonHostInstance = function(hierarchy) {
-    for (var i = hierarchy.length - 1; i > 1; i--) {
-        var instance = hierarchy[i];
-        if (instance.tag !== HostComponent$11) return instance;
-    }
-    return hierarchy[0];
-}, getHostProps = function(fiber) {
-    var host = ReactFiberTreeReflection.findCurrentHostFiber(fiber);
-    return host ? host.memoizedProps || emptyObject : emptyObject;
-}, getHostNode = function(fiber, findNodeHandle) {
-    for (var hostNode = void 0; fiber; ) {
-        if (null !== fiber.stateNode && fiber.tag === HostComponent$11 && (hostNode = findNodeHandle(fiber.stateNode)), 
-        hostNode) return hostNode;
-        fiber = fiber.child;
-    }
-    return null;
-}, createHierarchy = function(fiberHierarchy) {
-    return fiberHierarchy.map(function(fiber) {
-        return {
-            name: getComponentName_1(fiber),
-            getInspectorData: function(findNodeHandle) {
-                return {
-                    measure: function(callback) {
-                        return UIManager.measure(getHostNode(fiber, findNodeHandle), callback);
-                    },
-                    props: getHostProps(fiber),
-                    source: fiber._debugSource
-                };
-            }
-        };
-    });
-};
-
-getInspectorDataForViewTag = function(viewTag) {
-    var closestInstance = getClosestInstanceFromNode(viewTag);
-    if (!closestInstance) return {
-        hierarchy: [],
-        props: emptyObject,
-        selection: null,
-        source: null
-    };
-    var fiber = findCurrentFiberUsingSlowPath$1(closestInstance), fiberHierarchy = getOwnerHierarchy(fiber), instance = lastNonHostInstance(fiberHierarchy), hierarchy = createHierarchy(fiberHierarchy), props = getHostProps(instance), source = instance._debugSource;
-    return {
-        hierarchy: hierarchy,
-        props: props,
-        selection: fiberHierarchy.indexOf(instance),
-        source: source
-    };
-};
-
-var ReactNativeFiberInspector = {
-    getInspectorDataForViewTag: getInspectorDataForViewTag
-}, ReactVersion = "16.0.0-alpha.13", ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), ReactCurrentOwner$3 = ReactGlobalSharedState_1.ReactCurrentOwner, injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
-    return ReactNativeFiberRenderer.findHostInstance(fiber);
-} : function(instance) {
-    return instance;
-};
-
-function findNodeHandle(componentOrHandle) {
-    var owner = ReactCurrentOwner$3.current;
-    if (null !== owner && (warning(owner._warnedAboutRefsInRender, "%s is accessing findNodeHandle 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.", owner.getName() || "A component"), 
-    owner._warnedAboutRefsInRender = !0), null == componentOrHandle) return null;
-    if ("number" == typeof componentOrHandle) return componentOrHandle;
-    var component = componentOrHandle, internalInstance = ReactInstanceMap_1.get(component);
-    return internalInstance ? injectedFindNode(internalInstance) : component || (invariant("object" == typeof component && ("_rootNodeID" in component || "_nativeTag" in component) || null != component.render && "function" == typeof component.render, "findNodeHandle(...): Argument is not a component " + "(type: %s, keys: %s)", typeof component, Object.keys(component)), 
-    void invariant(!1, "findNodeHandle(...): Unable to find node handle for unmounted " + "component."));
-}
-
-var findNodeHandle_1 = findNodeHandle, findNumericNodeHandleFiber = function(componentOrHandle) {
-    var instance = findNodeHandle_1(componentOrHandle);
-    return null == instance || "number" == typeof instance ? instance : instance._nativeTag;
-}, DevOnlyStubShim = null;
-
-function _classCallCheck$2(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-function _possibleConstructorReturn(self, call) {
-    if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    return !call || "object" != typeof call && "function" != typeof call ? self : call;
-}
-
-function _inherits(subClass, superClass) {
-    if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            enumerable: !1,
-            writable: !0,
-            configurable: !0
-        }
-    }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
-}
-
-var ReactNativeFeatureFlags$1 = require("ReactNativeFeatureFlags"), mountSafeCallback$2 = NativeMethodsMixinUtils.mountSafeCallback, findNumericNodeHandle = ReactNativeFeatureFlags$1.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim, ReactNativeComponent = function(_React$Component) {
-    _inherits(ReactNativeComponent, _React$Component);
-    function ReactNativeComponent() {
-        return _classCallCheck$2(this, ReactNativeComponent), _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
-    }
-    return ReactNativeComponent.prototype.blur = function() {
-        TextInputState.blurTextInput(findNumericNodeHandle(this));
-    }, ReactNativeComponent.prototype.focus = function() {
-        TextInputState.focusTextInput(findNumericNodeHandle(this));
-    }, ReactNativeComponent.prototype.measure = function(callback) {
-        UIManager.measure(findNumericNodeHandle(this), mountSafeCallback$2(this, callback));
-    }, ReactNativeComponent.prototype.measureInWindow = function(callback) {
-        UIManager.measureInWindow(findNumericNodeHandle(this), mountSafeCallback$2(this, callback));
-    }, ReactNativeComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
-        UIManager.measureLayout(findNumericNodeHandle(this), relativeToNativeNode, mountSafeCallback$2(this, onFail), mountSafeCallback$2(this, onSuccess));
-    }, ReactNativeComponent.prototype.setNativeProps = function(nativeProps) {
-        injectedSetNativeProps(this, nativeProps);
-    }, ReactNativeComponent;
-}(react.Component);
-
-function setNativePropsFiber(componentOrHandle, nativeProps) {
-    var maybeInstance = void 0;
-    try {
-        maybeInstance = findNodeHandle_1(componentOrHandle);
-    } catch (error) {}
-    if (null != maybeInstance) {
-        var viewConfig = maybeInstance.viewConfig, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-function setNativePropsStack(componentOrHandle, nativeProps) {
-    var maybeInstance = findNodeHandle_1(componentOrHandle);
-    if (null != maybeInstance) {
-        var viewConfig = void 0;
-        if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
-            for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
-            viewConfig = maybeInstance.viewConfig;
-        }
-        var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-var injectedSetNativeProps = void 0;
-
-injectedSetNativeProps = ReactNativeFeatureFlags$1.useFiber ? setNativePropsFiber : setNativePropsStack;
-
-var ReactNativeComponent_1 = ReactNativeComponent, ReactNativeFeatureFlags$2 = require("ReactNativeFeatureFlags"), mountSafeCallback$3 = NativeMethodsMixinUtils.mountSafeCallback, throwOnStylesProp$1 = NativeMethodsMixinUtils.throwOnStylesProp, warnForStyleProps$2 = NativeMethodsMixinUtils.warnForStyleProps, findNumericNodeHandle$1 = ReactNativeFeatureFlags$2.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim, NativeMethodsMixin = {
-    measure: function(callback) {
-        UIManager.measure(findNumericNodeHandle$1(this), mountSafeCallback$3(this, callback));
-    },
-    measureInWindow: function(callback) {
-        UIManager.measureInWindow(findNumericNodeHandle$1(this), mountSafeCallback$3(this, callback));
-    },
-    measureLayout: function(relativeToNativeNode, onSuccess, onFail) {
-        UIManager.measureLayout(findNumericNodeHandle$1(this), relativeToNativeNode, mountSafeCallback$3(this, onFail), mountSafeCallback$3(this, onSuccess));
-    },
-    setNativeProps: function(nativeProps) {
-        injectedSetNativeProps$1(this, nativeProps);
-    },
-    focus: function() {
-        TextInputState.focusTextInput(findNumericNodeHandle$1(this));
-    },
-    blur: function() {
-        TextInputState.blurTextInput(findNumericNodeHandle$1(this));
-    }
-};
-
-function setNativePropsFiber$1(componentOrHandle, nativeProps) {
-    var maybeInstance = void 0;
-    try {
-        maybeInstance = findNodeHandle_1(componentOrHandle);
-    } catch (error) {}
-    if (null != maybeInstance) {
-        var viewConfig = maybeInstance.viewConfig;
-        warnForStyleProps$2(nativeProps, viewConfig.validAttributes);
-        var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-function setNativePropsStack$1(componentOrHandle, nativeProps) {
-    var maybeInstance = findNodeHandle_1(componentOrHandle);
-    if (null != maybeInstance) {
-        var viewConfig = void 0;
-        if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
-            for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
-            viewConfig = maybeInstance.viewConfig;
-        }
-        var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID;
-        warnForStyleProps$2(nativeProps, viewConfig.validAttributes);
-        var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-var injectedSetNativeProps$1 = void 0;
-
-injectedSetNativeProps$1 = ReactNativeFeatureFlags$2.useFiber ? setNativePropsFiber$1 : setNativePropsStack$1;
-
-var NativeMethodsMixin_DEV = NativeMethodsMixin;
-
-invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps, "Do not override existing functions."), 
-NativeMethodsMixin_DEV.componentWillMount = function() {
-    throwOnStylesProp$1(this, this.props);
-}, NativeMethodsMixin_DEV.componentWillReceiveProps = function(newProps) {
-    throwOnStylesProp$1(this, newProps);
-};
-
-var NativeMethodsMixin_1 = NativeMethodsMixin, TouchHistoryMath = {
-    centroidDimension: function(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
-        var touchBank = touchHistory.touchBank, total = 0, count = 0, oneTouchData = 1 === touchHistory.numberActiveTouches ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
-        if (null !== oneTouchData) oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter && (total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY, 
-        count = 1); else for (var i = 0; i < touchBank.length; i++) {
-            var touchTrack = touchBank[i];
-            if (null !== touchTrack && void 0 !== touchTrack && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
-                var toAdd;
-                toAdd = ofCurrent && isXAxis ? touchTrack.currentPageX : ofCurrent && !isXAxis ? touchTrack.currentPageY : !ofCurrent && isXAxis ? touchTrack.previousPageX : touchTrack.previousPageY, 
-                total += toAdd, count++;
-            }
-        }
-        return count > 0 ? total / count : TouchHistoryMath.noCentroid;
-    },
-    currentCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !0);
-    },
-    currentCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !0);
-    },
-    previousCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !1);
-    },
-    previousCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !1);
-    },
-    currentCentroidX: function(touchHistory) {
-        return TouchHistoryMath.centroidDimension(touchHistory, 0, !0, !0);
-    },
-    currentCentroidY: function(touchHistory) {
-        return TouchHistoryMath.centroidDimension(touchHistory, 0, !1, !0);
-    },
-    noCentroid: -1
-}, TouchHistoryMath_1 = TouchHistoryMath, createReactNativeComponentClassFiber = function(viewConfig) {
-    return ReactNativeViewConfigRegistry_1.register(viewConfig);
-}, createReactNativeComponentClassFiber_1 = createReactNativeComponentClassFiber, ReactNativeFeatureFlags$3 = require("ReactNativeFeatureFlags"), createReactNativeComponentClass = ReactNativeFeatureFlags$3.useFiber ? createReactNativeComponentClassFiber_1 : DevOnlyStubShim, ReactNativeFeatureFlags$4 = require("ReactNativeFeatureFlags"), findNumericNodeHandle$2 = ReactNativeFeatureFlags$4.useFiber ? findNumericNodeHandleFiber : DevOnlyStubShim;
-
-function takeSnapshot(view, options) {
-    return "number" != typeof view && "window" !== view && (view = findNumericNodeHandle$2(view) || "window"), 
-    UIManager.__takeSnapshot(view, options);
-}
-
-var takeSnapshot_1 = takeSnapshot, ReactInvalidSetStateWarningHook = {}, processingChildContext = !1, warnInvalidSetState = function() {
-    warning(!processingChildContext, "setState(...): Cannot call setState() inside getChildContext()");
-};
-
-ReactInvalidSetStateWarningHook = {
-    onBeginProcessingChildContext: function() {
-        processingChildContext = !0;
-    },
-    onEndProcessingChildContext: function() {
-        processingChildContext = !1;
-    },
-    onSetState: function() {
-        warnInvalidSetState();
-    }
-};
-
-var ReactInvalidSetStateWarningHook_1 = ReactInvalidSetStateWarningHook, ReactHostOperationHistoryHook = null, history = [];
-
-ReactHostOperationHistoryHook = {
-    onHostOperation: function(operation) {
-        history.push(operation);
-    },
-    clearHistory: function() {
-        ReactHostOperationHistoryHook._preventClearing || (history = []);
-    },
-    getHistory: function() {
-        return history;
-    }
-};
-
-var ReactHostOperationHistoryHook_1 = ReactHostOperationHistoryHook, ReactComponentTreeHook = ReactGlobalSharedState_1.ReactComponentTreeHook, ReactDebugTool = null, hooks = [], didHookThrowForEvent = {}, callHook = function(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
-    try {
-        fn.call(context, arg1, arg2, arg3, arg4, arg5);
-    } catch (e) {
-        warning(didHookThrowForEvent[event], "Exception thrown by hook while handling %s: %s", event, e + "\n" + e.stack), 
-        didHookThrowForEvent[event] = !0;
-    }
-}, emitEvent = function(event, arg1, arg2, arg3, arg4, arg5) {
-    for (var i = 0; i < hooks.length; i++) {
-        var hook = hooks[i], fn = hook[event];
-        fn && callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
-    }
-}, isProfiling = !1, flushHistory = [], lifeCycleTimerStack = [], currentFlushNesting = 0, currentFlushMeasurements = [], currentFlushStartTime = 0, currentTimerDebugID = null, currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerType = null, lifeCycleTimerHasWarned = !1, clearHistory = function() {
-    ReactComponentTreeHook.purgeUnmountedComponents(), ReactHostOperationHistoryHook_1.clearHistory();
-}, getTreeSnapshot = function(registeredIDs) {
-    return registeredIDs.reduce(function(tree, id) {
-        var ownerID = ReactComponentTreeHook.getOwnerID(id), parentID = ReactComponentTreeHook.getParentID(id);
-        return tree[id] = {
-            displayName: ReactComponentTreeHook.getDisplayName(id),
-            text: ReactComponentTreeHook.getText(id),
-            updateCount: ReactComponentTreeHook.getUpdateCount(id),
-            childIDs: ReactComponentTreeHook.getChildIDs(id),
-            ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
-            parentID: parentID
-        }, tree;
-    }, {});
-}, resetMeasurements = function() {
-    var previousStartTime = currentFlushStartTime, previousMeasurements = currentFlushMeasurements, previousOperations = ReactHostOperationHistoryHook_1.getHistory();
-    if (0 === currentFlushNesting) return currentFlushStartTime = 0, currentFlushMeasurements = [], 
-    void clearHistory();
-    if (previousMeasurements.length || previousOperations.length) {
-        var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
-        flushHistory.push({
-            duration: performanceNow() - previousStartTime,
-            measurements: previousMeasurements || [],
-            operations: previousOperations || [],
-            treeSnapshot: getTreeSnapshot(registeredIDs)
-        });
-    }
-    clearHistory(), currentFlushStartTime = performanceNow(), currentFlushMeasurements = [];
-}, checkDebugID = function(debugID) {
-    arguments.length > 1 && void 0 !== arguments[1] && arguments[1] && 0 === debugID || debugID || warning(!1, "ReactDebugTool: debugID may not be empty.");
-}, beginLifeCycleTimer = function(debugID, timerType) {
-    0 !== currentFlushNesting && (currentTimerType && !lifeCycleTimerHasWarned && (warning(!1, "There is an internal error in the React performance measurement code." + "\n\nDid not expect %s timer to start while %s timer is still in " + "progress for %s instance.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
-    lifeCycleTimerHasWarned = !0), currentTimerStartTime = performanceNow(), currentTimerNestedFlushDuration = 0, 
-    currentTimerDebugID = debugID, currentTimerType = timerType);
-}, endLifeCycleTimer = function(debugID, timerType) {
-    0 !== currentFlushNesting && (currentTimerType === timerType || lifeCycleTimerHasWarned || (warning(!1, "There is an internal error in the React performance measurement code. " + "We did not expect %s timer to stop while %s timer is still in " + "progress for %s instance. Please report this as a bug in React.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
-    lifeCycleTimerHasWarned = !0), isProfiling && currentFlushMeasurements.push({
-        timerType: timerType,
-        instanceID: debugID,
-        duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
-    }), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerDebugID = null, 
-    currentTimerType = null);
-}, pauseCurrentLifeCycleTimer = function() {
-    var currentTimer = {
-        startTime: currentTimerStartTime,
-        nestedFlushStartTime: performanceNow(),
-        debugID: currentTimerDebugID,
-        timerType: currentTimerType
-    };
-    lifeCycleTimerStack.push(currentTimer), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, 
-    currentTimerDebugID = null, currentTimerType = null;
-}, resumeCurrentLifeCycleTimer = function() {
-    var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(), startTime = _lifeCycleTimerStack$.startTime, nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime, debugID = _lifeCycleTimerStack$.debugID, timerType = _lifeCycleTimerStack$.timerType, nestedFlushDuration = performanceNow() - nestedFlushStartTime;
-    currentTimerStartTime = startTime, currentTimerNestedFlushDuration += nestedFlushDuration, 
-    currentTimerDebugID = debugID, currentTimerType = timerType;
-}, lastMarkTimeStamp = 0, canUsePerformanceMeasure = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, shouldMark = function(debugID) {
-    if (!isProfiling || !canUsePerformanceMeasure) return !1;
-    var element = ReactComponentTreeHook.getElement(debugID);
-    return null != element && "object" == typeof element && !("string" == typeof element.type);
-}, markBegin = function(debugID, markType) {
-    if (shouldMark(debugID)) {
-        var markName = debugID + "::" + markType;
-        lastMarkTimeStamp = performanceNow(), performance.mark(markName);
-    }
-}, markEnd = function(debugID, markType) {
-    if (shouldMark(debugID)) {
-        var markName = debugID + "::" + markType, displayName = ReactComponentTreeHook.getDisplayName(debugID) || "Unknown";
-        if (performanceNow() - lastMarkTimeStamp > .1) {
-            var measurementName = displayName + " [" + markType + "]";
-            performance.measure(measurementName, markName);
-        }
-        performance.clearMarks(markName), measurementName && performance.clearMeasures(measurementName);
-    }
-};
-
-ReactDebugTool = {
-    addHook: function(hook) {
-        hooks.push(hook);
-    },
-    removeHook: function(hook) {
-        for (var i = 0; i < hooks.length; i++) hooks[i] === hook && (hooks.splice(i, 1), 
-        i--);
-    },
-    isProfiling: function() {
-        return isProfiling;
-    },
-    beginProfiling: function() {
-        isProfiling || (isProfiling = !0, flushHistory.length = 0, resetMeasurements(), 
-        ReactDebugTool.addHook(ReactHostOperationHistoryHook_1));
-    },
-    endProfiling: function() {
-        isProfiling && (isProfiling = !1, resetMeasurements(), ReactDebugTool.removeHook(ReactHostOperationHistoryHook_1));
-    },
-    getFlushHistory: function() {
-        return flushHistory;
-    },
-    onBeginFlush: function() {
-        currentFlushNesting++, resetMeasurements(), pauseCurrentLifeCycleTimer(), emitEvent("onBeginFlush");
-    },
-    onEndFlush: function() {
-        resetMeasurements(), currentFlushNesting--, resumeCurrentLifeCycleTimer(), emitEvent("onEndFlush");
-    },
-    onBeginLifeCycleTimer: function(debugID, timerType) {
-        checkDebugID(debugID), emitEvent("onBeginLifeCycleTimer", debugID, timerType), markBegin(debugID, timerType), 
-        beginLifeCycleTimer(debugID, timerType);
-    },
-    onEndLifeCycleTimer: function(debugID, timerType) {
-        checkDebugID(debugID), endLifeCycleTimer(debugID, timerType), markEnd(debugID, timerType), 
-        emitEvent("onEndLifeCycleTimer", debugID, timerType);
-    },
-    onBeginProcessingChildContext: function() {
-        emitEvent("onBeginProcessingChildContext");
-    },
-    onEndProcessingChildContext: function() {
-        emitEvent("onEndProcessingChildContext");
-    },
-    onHostOperation: function(operation) {
-        checkDebugID(operation.instanceID), emitEvent("onHostOperation", operation);
-    },
-    onSetState: function() {
-        emitEvent("onSetState");
-    },
-    onSetChildren: function(debugID, childDebugIDs) {
-        checkDebugID(debugID), childDebugIDs.forEach(checkDebugID), emitEvent("onSetChildren", debugID, childDebugIDs);
-    },
-    onBeforeMountComponent: function(debugID, element, parentDebugID) {
-        checkDebugID(debugID), checkDebugID(parentDebugID, !0), emitEvent("onBeforeMountComponent", debugID, element, parentDebugID), 
-        markBegin(debugID, "mount");
-    },
-    onMountComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "mount"), emitEvent("onMountComponent", debugID);
-    },
-    onBeforeUpdateComponent: function(debugID, element) {
-        checkDebugID(debugID), emitEvent("onBeforeUpdateComponent", debugID, element), markBegin(debugID, "update");
-    },
-    onUpdateComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "update"), emitEvent("onUpdateComponent", debugID);
-    },
-    onBeforeUnmountComponent: function(debugID) {
-        checkDebugID(debugID), emitEvent("onBeforeUnmountComponent", debugID), markBegin(debugID, "unmount");
-    },
-    onUnmountComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "unmount"), emitEvent("onUnmountComponent", debugID);
-    },
-    onTestEvent: function() {
-        emitEvent("onTestEvent");
-    }
-}, ReactDebugTool.addHook(ReactInvalidSetStateWarningHook_1), ReactDebugTool.addHook(ReactComponentTreeHook);
-
-var url = ExecutionEnvironment.canUseDOM && window.location.href || "";
-
-/[?&]react_perf\b/.test(url) && ReactDebugTool.beginProfiling();
-
-var ReactDebugTool_1 = ReactDebugTool, lowPriorityWarning = function() {}, printWarning = function(format) {
-    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
-    var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
-        return args[argIndex++];
-    });
-    "undefined" != typeof console && console.warn(message);
-    try {
-        throw new Error(message);
-    } catch (x) {}
-};
-
-lowPriorityWarning = function(condition, format) {
-    if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning " + "message argument");
-    if (!condition) {
-        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2];
-        printWarning.apply(void 0, [ format ].concat(args));
-    }
-};
-
-var lowPriorityWarning_1 = lowPriorityWarning, _extends$3 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-};
-
-function roundFloat(val) {
-    var base = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 2, n = Math.pow(10, base);
-    return Math.floor(val * n) / n;
-}
-
-function consoleTable(table) {
-    console.table(table);
-}
-
-function getLastMeasurements() {
-    return ReactDebugTool_1.getFlushHistory();
-}
-
-function getExclusive() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, timerType, applyUpdate) {
-        var displayName = treeSnapshot[instanceID].displayName, key = displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            counts: {},
-            durations: {},
-            totalDuration: 0
-        }), stats.durations[timerType] || (stats.durations[timerType] = 0), stats.counts[timerType] || (stats.counts[timerType] = 0), 
-        affectedIDs[key][instanceID] = !0, applyUpdate(stats);
-    }
-    return flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
-        measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID, timerType = measurement.timerType;
-            updateAggregatedStats(treeSnapshot, instanceID, timerType, function(stats) {
-                stats.totalDuration += duration, stats.durations[timerType] += duration, stats.counts[timerType]++;
+    }, isProfiling = !1, flushHistory = [], lifeCycleTimerStack = [], currentFlushNesting = 0, currentFlushMeasurements = [], currentFlushStartTime = 0, currentTimerDebugID = null, currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerType = null, lifeCycleTimerHasWarned = !1, clearHistory = function() {
+        ReactComponentTreeHook.purgeUnmountedComponents(), ReactHostOperationHistoryHook_1.clearHistory();
+    }, getTreeSnapshot = function(registeredIDs) {
+        return registeredIDs.reduce(function(tree, id) {
+            var ownerID = ReactComponentTreeHook.getOwnerID(id), parentID = ReactComponentTreeHook.getParentID(id);
+            return tree[id] = {
+                displayName: ReactComponentTreeHook.getDisplayName(id),
+                text: ReactComponentTreeHook.getText(id),
+                updateCount: ReactComponentTreeHook.getUpdateCount(id),
+                childIDs: ReactComponentTreeHook.getChildIDs(id),
+                ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
+                parentID: parentID
+            }, tree;
+        }, {});
+    }, resetMeasurements = function() {
+        var previousStartTime = currentFlushStartTime, previousMeasurements = currentFlushMeasurements, previousOperations = ReactHostOperationHistoryHook_1.getHistory();
+        if (0 === currentFlushNesting) return currentFlushStartTime = 0, currentFlushMeasurements = [], 
+        void clearHistory();
+        if (previousMeasurements.length || previousOperations.length) {
+            var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
+            flushHistory.push({
+                duration: performanceNow() - previousStartTime,
+                measurements: previousMeasurements || [],
+                operations: previousOperations || [],
+                treeSnapshot: getTreeSnapshot(registeredIDs)
             });
-        });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$3({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.totalDuration - a.totalDuration;
-    });
-}
-
-function getInclusive() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
-        var _treeSnapshot$instanc = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc.displayName, ownerID = _treeSnapshot$instanc.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            inclusiveRenderDuration: 0,
-            renderCount: 0
-        }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
-    }
-    var isCompositeByID = {};
-    return flushHistory.forEach(function(flush) {
-        flush.measurements.forEach(function(measurement) {
-            var instanceID = measurement.instanceID;
-            "render" === measurement.timerType && (isCompositeByID[instanceID] = !0);
-        });
-    }), flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
-        measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID;
-            if ("render" === measurement.timerType) {
-                updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
-                    stats.renderCount++;
-                });
-                for (var nextParentID = instanceID; nextParentID; ) isCompositeByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
-                    stats.inclusiveRenderDuration += duration;
-                }), nextParentID = treeSnapshot[nextParentID].parentID;
+        }
+        clearHistory(), currentFlushStartTime = performanceNow(), currentFlushMeasurements = [];
+    }, checkDebugID = function(debugID) {
+        arguments.length > 1 && void 0 !== arguments[1] && arguments[1] && 0 === debugID || debugID || warning$14(!1, "ReactDebugTool: debugID may not be empty.");
+    }, beginLifeCycleTimer = function(debugID, timerType) {
+        0 !== currentFlushNesting && (currentTimerType && !lifeCycleTimerHasWarned && (warning$14(!1, "There is an internal error in the React performance measurement code." + "\n\nDid not expect %s timer to start while %s timer is still in " + "progress for %s instance.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
+        lifeCycleTimerHasWarned = !0), currentTimerStartTime = performanceNow(), currentTimerNestedFlushDuration = 0, 
+        currentTimerDebugID = debugID, currentTimerType = timerType);
+    }, endLifeCycleTimer = function(debugID, timerType) {
+        0 !== currentFlushNesting && (currentTimerType === timerType || lifeCycleTimerHasWarned || (warning$14(!1, "There is an internal error in the React performance measurement code. " + "We did not expect %s timer to stop while %s timer is still in " + "progress for %s instance. Please report this as a bug in React.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
+        lifeCycleTimerHasWarned = !0), isProfiling && currentFlushMeasurements.push({
+            timerType: timerType,
+            instanceID: debugID,
+            duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
+        }), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerDebugID = null, 
+        currentTimerType = null);
+    }, pauseCurrentLifeCycleTimer = function() {
+        var currentTimer = {
+            startTime: currentTimerStartTime,
+            nestedFlushStartTime: performanceNow(),
+            debugID: currentTimerDebugID,
+            timerType: currentTimerType
+        };
+        lifeCycleTimerStack.push(currentTimer), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, 
+        currentTimerDebugID = null, currentTimerType = null;
+    }, resumeCurrentLifeCycleTimer = function() {
+        var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(), startTime = _lifeCycleTimerStack$.startTime, nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime, debugID = _lifeCycleTimerStack$.debugID, timerType = _lifeCycleTimerStack$.timerType, nestedFlushDuration = performanceNow() - nestedFlushStartTime;
+        currentTimerStartTime = startTime, currentTimerNestedFlushDuration += nestedFlushDuration, 
+        currentTimerDebugID = debugID, currentTimerType = timerType;
+    }, lastMarkTimeStamp = 0, canUsePerformanceMeasure = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, shouldMark = function(debugID) {
+        if (!isProfiling || !canUsePerformanceMeasure) return !1;
+        var element = ReactComponentTreeHook.getElement(debugID);
+        return null != element && "object" == typeof element && !("string" == typeof element.type);
+    }, markBegin = function(debugID, markType) {
+        if (shouldMark(debugID)) {
+            var markName = debugID + "::" + markType;
+            lastMarkTimeStamp = performanceNow(), performance.mark(markName);
+        }
+    }, markEnd = function(debugID, markType) {
+        if (shouldMark(debugID)) {
+            var markName = debugID + "::" + markType, displayName = ReactComponentTreeHook.getDisplayName(debugID) || "Unknown";
+            if (performanceNow() - lastMarkTimeStamp > .1) {
+                var measurementName = displayName + " [" + markType + "]";
+                performance.measure(measurementName, markName);
             }
+            performance.clearMarks(markName), measurementName && performance.clearMeasures(measurementName);
+        }
+    };
+    ReactDebugTool = {
+        addHook: function(hook) {
+            hooks.push(hook);
+        },
+        removeHook: function(hook) {
+            for (var i = 0; i < hooks.length; i++) hooks[i] === hook && (hooks.splice(i, 1), 
+            i--);
+        },
+        isProfiling: function() {
+            return isProfiling;
+        },
+        beginProfiling: function() {
+            isProfiling || (isProfiling = !0, flushHistory.length = 0, resetMeasurements(), 
+            ReactDebugTool.addHook(ReactHostOperationHistoryHook_1));
+        },
+        endProfiling: function() {
+            isProfiling && (isProfiling = !1, resetMeasurements(), ReactDebugTool.removeHook(ReactHostOperationHistoryHook_1));
+        },
+        getFlushHistory: function() {
+            return flushHistory;
+        },
+        onBeginFlush: function() {
+            currentFlushNesting++, resetMeasurements(), pauseCurrentLifeCycleTimer(), emitEvent("onBeginFlush");
+        },
+        onEndFlush: function() {
+            resetMeasurements(), currentFlushNesting--, resumeCurrentLifeCycleTimer(), emitEvent("onEndFlush");
+        },
+        onBeginLifeCycleTimer: function(debugID, timerType) {
+            checkDebugID(debugID), emitEvent("onBeginLifeCycleTimer", debugID, timerType), markBegin(debugID, timerType), 
+            beginLifeCycleTimer(debugID, timerType);
+        },
+        onEndLifeCycleTimer: function(debugID, timerType) {
+            checkDebugID(debugID), endLifeCycleTimer(debugID, timerType), markEnd(debugID, timerType), 
+            emitEvent("onEndLifeCycleTimer", debugID, timerType);
+        },
+        onBeginProcessingChildContext: function() {
+            emitEvent("onBeginProcessingChildContext");
+        },
+        onEndProcessingChildContext: function() {
+            emitEvent("onEndProcessingChildContext");
+        },
+        onHostOperation: function(operation) {
+            checkDebugID(operation.instanceID), emitEvent("onHostOperation", operation);
+        },
+        onSetState: function() {
+            emitEvent("onSetState");
+        },
+        onSetChildren: function(debugID, childDebugIDs) {
+            checkDebugID(debugID), childDebugIDs.forEach(checkDebugID), emitEvent("onSetChildren", debugID, childDebugIDs);
+        },
+        onBeforeMountComponent: function(debugID, element, parentDebugID) {
+            checkDebugID(debugID), checkDebugID(parentDebugID, !0), emitEvent("onBeforeMountComponent", debugID, element, parentDebugID), 
+            markBegin(debugID, "mount");
+        },
+        onMountComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "mount"), emitEvent("onMountComponent", debugID);
+        },
+        onBeforeUpdateComponent: function(debugID, element) {
+            checkDebugID(debugID), emitEvent("onBeforeUpdateComponent", debugID, element), markBegin(debugID, "update");
+        },
+        onUpdateComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "update"), emitEvent("onUpdateComponent", debugID);
+        },
+        onBeforeUnmountComponent: function(debugID) {
+            checkDebugID(debugID), emitEvent("onBeforeUnmountComponent", debugID), markBegin(debugID, "unmount");
+        },
+        onUnmountComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "unmount"), emitEvent("onUnmountComponent", debugID);
+        },
+        onTestEvent: function() {
+            emitEvent("onTestEvent");
+        }
+    }, ReactDebugTool.addHook(ReactInvalidSetStateWarningHook_1), ReactDebugTool.addHook(ReactComponentTreeHook), 
+    /[?&]react_perf\b/.test(ExecutionEnvironment.canUseDOM && window.location.href || "") && ReactDebugTool.beginProfiling();
+    var ReactDebugTool_1 = ReactDebugTool, lowPriorityWarning = function() {}, printWarning = function(format) {
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
+        var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
+            return args[argIndex++];
         });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$3({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
-    });
-}
-
-function getWasted() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
-        var _treeSnapshot$instanc2 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc2.displayName, ownerID = _treeSnapshot$instanc2.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            inclusiveRenderDuration: 0,
-            renderCount: 0
-        }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        "undefined" != typeof console && console.warn(message);
+        try {
+            throw new Error(message);
+        } catch (x) {}
+    };
+    lowPriorityWarning = function(condition, format) {
+        if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning " + "message argument");
+        if (!condition) {
+            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2];
+            printWarning.apply(void 0, [ format ].concat(args));
+        }
+    };
+    var lowPriorityWarning_1 = lowPriorityWarning;
+    function roundFloat(val) {
+        var base = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 2, n = Math.pow(10, base);
+        return Math.floor(val * n) / n;
     }
-    return flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot, operations = flush.operations, isDefinitelyNotWastedByID = {};
-        operations.forEach(function(operation) {
-            for (var instanceID = operation.instanceID, nextParentID = instanceID; nextParentID; ) isDefinitelyNotWastedByID[nextParentID] = !0, 
-            nextParentID = treeSnapshot[nextParentID].parentID;
+    function consoleTable(table) {
+        console.table(table);
+    }
+    function getLastMeasurements() {
+        return ReactDebugTool_1.getFlushHistory();
+    }
+    function getExclusive() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, timerType, applyUpdate) {
+            var displayName = treeSnapshot[instanceID].displayName, key = displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                counts: {},
+                durations: {},
+                totalDuration: 0
+            }), stats.durations[timerType] || (stats.durations[timerType] = 0), stats.counts[timerType] || (stats.counts[timerType] = 0), 
+            affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        }
+        return flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
+            measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID, timerType = measurement.timerType;
+                updateAggregatedStats(treeSnapshot, instanceID, timerType, function(stats) {
+                    stats.totalDuration += duration, stats.durations[timerType] += duration, stats.counts[timerType]++;
+                });
+            });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.totalDuration - a.totalDuration;
         });
-        var renderedCompositeIDs = {};
-        measurements.forEach(function(measurement) {
-            var instanceID = measurement.instanceID;
-            "render" === measurement.timerType && (renderedCompositeIDs[instanceID] = !0);
-        }), measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID;
-            if ("render" === measurement.timerType) {
-                var updateCount = treeSnapshot[instanceID].updateCount;
-                if (!isDefinitelyNotWastedByID[instanceID] && 0 !== updateCount) {
+    }
+    function getInclusive() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
+            var _treeSnapshot$instanc = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc.displayName, ownerID = _treeSnapshot$instanc.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                inclusiveRenderDuration: 0,
+                renderCount: 0
+            }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        }
+        var isCompositeByID = {};
+        return flushHistory.forEach(function(flush) {
+            flush.measurements.forEach(function(measurement) {
+                var instanceID = measurement.instanceID;
+                "render" === measurement.timerType && (isCompositeByID[instanceID] = !0);
+            });
+        }), flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
+            measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID;
+                if ("render" === measurement.timerType) {
                     updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
                         stats.renderCount++;
                     });
-                    for (var nextParentID = instanceID; nextParentID; ) renderedCompositeIDs[nextParentID] && !isDefinitelyNotWastedByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
+                    for (var nextParentID = instanceID; nextParentID; ) isCompositeByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
                         stats.inclusiveRenderDuration += duration;
                     }), nextParentID = treeSnapshot[nextParentID].parentID;
                 }
-            }
-        });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$3({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
-    });
-}
-
-function getOperations() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), stats = [];
-    return flushHistory.forEach(function(flush, flushIndex) {
-        var operations = flush.operations, treeSnapshot = flush.treeSnapshot;
-        operations.forEach(function(operation) {
-            var instanceID = operation.instanceID, type = operation.type, payload = operation.payload, _treeSnapshot$instanc3 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc3.displayName, ownerID = _treeSnapshot$instanc3.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName;
-            stats.push({
-                flushIndex: flushIndex,
-                instanceID: instanceID,
-                key: key,
-                type: type,
-                ownerID: ownerID,
-                payload: payload
             });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
         });
-    }), stats;
-}
-
-function printExclusive(flushHistory) {
-    consoleTable(getExclusive(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, totalDuration = item.totalDuration, renderCount = item.counts.render || 0, renderDuration = item.durations.render || 0;
-        return {
-            Component: key,
-            "Total time (ms)": roundFloat(totalDuration),
-            "Instance count": instanceCount,
-            "Total render time (ms)": roundFloat(renderDuration),
-            "Average render time (ms)": renderCount ? roundFloat(renderDuration / renderCount) : void 0,
-            "Render count": renderCount,
-            "Total lifecycle time (ms)": roundFloat(totalDuration - renderDuration)
-        };
-    }));
-}
-
-function printInclusive(flushHistory) {
-    consoleTable(getInclusive(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
-        return {
-            "Owner > Component": key,
-            "Inclusive render time (ms)": roundFloat(inclusiveRenderDuration),
-            "Instance count": instanceCount,
-            "Render count": renderCount
-        };
-    }));
-}
-
-function printWasted(flushHistory) {
-    consoleTable(getWasted(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
-        return {
-            "Owner > Component": key,
-            "Inclusive wasted time (ms)": roundFloat(inclusiveRenderDuration),
-            "Instance count": instanceCount,
-            "Render count": renderCount
-        };
-    }));
-}
-
-function printOperations(flushHistory) {
-    consoleTable(getOperations(flushHistory).map(function(stat) {
-        return {
-            "Owner > Node": stat.key,
-            Operation: stat.type,
-            Payload: "object" == typeof stat.payload ? JSON.stringify(stat.payload) : stat.payload,
-            "Flush index": stat.flushIndex,
-            "Owner Component ID": stat.ownerID,
-            "DOM Component ID": stat.instanceID
-        };
-    }));
-}
-
-var warnedAboutPrintDOM = !1;
-
-function printDOM(measurements) {
-    return lowPriorityWarning_1(warnedAboutPrintDOM, "`ReactPerf.printDOM(...)` is deprecated. Use " + "`ReactPerf.printOperations(...)` instead."), 
-    warnedAboutPrintDOM = !0, printOperations(measurements);
-}
-
-var warnedAboutGetMeasurementsSummaryMap = !1;
-
-function getMeasurementsSummaryMap(measurements) {
-    return lowPriorityWarning_1(warnedAboutGetMeasurementsSummaryMap, "`ReactPerf.getMeasurementsSummaryMap(...)` is deprecated. Use " + "`ReactPerf.getWasted(...)` instead."), 
-    warnedAboutGetMeasurementsSummaryMap = !0, getWasted(measurements);
-}
-
-function start() {
-    ReactDebugTool_1.beginProfiling();
-}
-
-function stop() {
-    ReactDebugTool_1.endProfiling();
-}
-
-function isRunning() {
-    return ReactDebugTool_1.isProfiling();
-}
-
-var ReactPerfAnalysis = {
-    getLastMeasurements: getLastMeasurements,
-    getExclusive: getExclusive,
-    getInclusive: getInclusive,
-    getWasted: getWasted,
-    getOperations: getOperations,
-    printExclusive: printExclusive,
-    printInclusive: printInclusive,
-    printWasted: printWasted,
-    printOperations: printOperations,
-    start: start,
-    stop: stop,
-    isRunning: isRunning,
-    printDOM: printDOM,
-    getMeasurementsSummaryMap: getMeasurementsSummaryMap
-}, ReactPerf = ReactPerfAnalysis, injectInternals = ReactFiberDevToolsHook.injectInternals;
-
-ReactNativeInjection.inject(), ReactGenericBatching_1.injection.injectFiberBatchedUpdates(ReactNativeFiberRenderer.batchedUpdates);
-
-var roots = new Map();
-
-ReactFiberErrorLogger.injection.injectDialog(ReactNativeFiberErrorDialog_1.showDialog);
-
-var ReactNativeFiber = {
-    NativeComponent: ReactNativeComponent_1,
-    findNodeHandle: findNumericNodeHandleFiber,
-    render: function(element, containerTag, callback) {
-        var root = roots.get(containerTag);
-        return root || (root = ReactNativeFiberRenderer.createContainer(containerTag), roots.set(containerTag, root)), 
-        ReactNativeFiberRenderer.updateContainer(element, root, null, callback), ReactNativeFiberRenderer.getPublicRootInstance(root);
-    },
-    unmountComponentAtNode: function(containerTag) {
-        var root = roots.get(containerTag);
-        root && ReactNativeFiberRenderer.updateContainer(null, root, null, function() {
-            roots.delete(containerTag);
-        });
-    },
-    unmountComponentAtNodeAndRemoveContainer: function(containerTag) {
-        ReactNativeFiber.unmountComponentAtNode(containerTag), UIManager.removeRootView(containerTag);
-    },
-    unstable_createPortal: function(children, containerTag) {
-        var key = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : null;
-        return ReactPortal.createPortal(children, containerTag, null, key);
-    },
-    unstable_batchedUpdates: ReactGenericBatching_1.batchedUpdates,
-    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
-        NativeMethodsMixin: NativeMethodsMixin_1,
-        ReactGlobalSharedState: ReactGlobalSharedState_1,
-        ReactNativeComponentTree: ReactNativeComponentTree_1,
-        ReactNativePropRegistry: ReactNativePropRegistry_1,
-        TouchHistoryMath: TouchHistoryMath_1,
-        createReactNativeComponentClass: createReactNativeComponentClass,
-        takeSnapshot: takeSnapshot_1
     }
-};
-
-Object.assign(ReactNativeFiber.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
-    ReactDebugTool: ReactDebugTool_1,
-    ReactPerf: ReactPerf
-}), "function" == typeof injectInternals && injectInternals({
-    findFiberByHostInstance: ReactNativeComponentTree_1.getClosestInstanceFromNode,
-    findHostInstanceByFiber: ReactNativeFiberRenderer.findHostInstance,
-    getInspectorDataForViewTag: ReactNativeFiberInspector.getInspectorDataForViewTag,
-    bundleType: 1,
-    version: ReactVersion
-});
-
-var ReactNativeFiberEntry = ReactNativeFiber;
-
-module.exports = ReactNativeFiberEntry;
+    function getWasted() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
+            var _treeSnapshot$instanc2 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc2.displayName, ownerID = _treeSnapshot$instanc2.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                inclusiveRenderDuration: 0,
+                renderCount: 0
+            }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        }
+        return flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot, operations = flush.operations, isDefinitelyNotWastedByID = {};
+            operations.forEach(function(operation) {
+                for (var instanceID = operation.instanceID, nextParentID = instanceID; nextParentID; ) isDefinitelyNotWastedByID[nextParentID] = !0, 
+                nextParentID = treeSnapshot[nextParentID].parentID;
+            });
+            var renderedCompositeIDs = {};
+            measurements.forEach(function(measurement) {
+                var instanceID = measurement.instanceID;
+                "render" === measurement.timerType && (renderedCompositeIDs[instanceID] = !0);
+            }), measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID;
+                if ("render" === measurement.timerType) {
+                    var updateCount = treeSnapshot[instanceID].updateCount;
+                    if (!isDefinitelyNotWastedByID[instanceID] && 0 !== updateCount) {
+                        updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
+                            stats.renderCount++;
+                        });
+                        for (var nextParentID = instanceID; nextParentID; ) renderedCompositeIDs[nextParentID] && !isDefinitelyNotWastedByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
+                            stats.inclusiveRenderDuration += duration;
+                        }), nextParentID = treeSnapshot[nextParentID].parentID;
+                    }
+                }
+            });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
+        });
+    }
+    function getOperations() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), stats = [];
+        return flushHistory.forEach(function(flush, flushIndex) {
+            var operations = flush.operations, treeSnapshot = flush.treeSnapshot;
+            operations.forEach(function(operation) {
+                var instanceID = operation.instanceID, type = operation.type, payload = operation.payload, _treeSnapshot$instanc3 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc3.displayName, ownerID = _treeSnapshot$instanc3.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName;
+                stats.push({
+                    flushIndex: flushIndex,
+                    instanceID: instanceID,
+                    key: key,
+                    type: type,
+                    ownerID: ownerID,
+                    payload: payload
+                });
+            });
+        }), stats;
+    }
+    function printExclusive(flushHistory) {
+        consoleTable(getExclusive(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, totalDuration = item.totalDuration, renderCount = item.counts.render || 0, renderDuration = item.durations.render || 0;
+            return {
+                Component: key,
+                "Total time (ms)": roundFloat(totalDuration),
+                "Instance count": instanceCount,
+                "Total render time (ms)": roundFloat(renderDuration),
+                "Average render time (ms)": renderCount ? roundFloat(renderDuration / renderCount) : void 0,
+                "Render count": renderCount,
+                "Total lifecycle time (ms)": roundFloat(totalDuration - renderDuration)
+            };
+        }));
+    }
+    function printInclusive(flushHistory) {
+        consoleTable(getInclusive(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
+            return {
+                "Owner > Component": key,
+                "Inclusive render time (ms)": roundFloat(inclusiveRenderDuration),
+                "Instance count": instanceCount,
+                "Render count": renderCount
+            };
+        }));
+    }
+    function printWasted(flushHistory) {
+        consoleTable(getWasted(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
+            return {
+                "Owner > Component": key,
+                "Inclusive wasted time (ms)": roundFloat(inclusiveRenderDuration),
+                "Instance count": instanceCount,
+                "Render count": renderCount
+            };
+        }));
+    }
+    function printOperations(flushHistory) {
+        consoleTable(getOperations(flushHistory).map(function(stat) {
+            return {
+                "Owner > Node": stat.key,
+                Operation: stat.type,
+                Payload: "object" == typeof stat.payload ? JSON.stringify(stat.payload) : stat.payload,
+                "Flush index": stat.flushIndex,
+                "Owner Component ID": stat.ownerID,
+                "DOM Component ID": stat.instanceID
+            };
+        }));
+    }
+    var warnedAboutPrintDOM = !1;
+    function printDOM(measurements) {
+        return lowPriorityWarning_1(warnedAboutPrintDOM, "`ReactPerf.printDOM(...)` is deprecated. Use " + "`ReactPerf.printOperations(...)` instead."), 
+        warnedAboutPrintDOM = !0, printOperations(measurements);
+    }
+    var warnedAboutGetMeasurementsSummaryMap = !1;
+    function getMeasurementsSummaryMap(measurements) {
+        return lowPriorityWarning_1(warnedAboutGetMeasurementsSummaryMap, "`ReactPerf.getMeasurementsSummaryMap(...)` is deprecated. Use " + "`ReactPerf.getWasted(...)` instead."), 
+        warnedAboutGetMeasurementsSummaryMap = !0, getWasted(measurements);
+    }
+    function start() {
+        ReactDebugTool_1.beginProfiling();
+    }
+    function stop() {
+        ReactDebugTool_1.endProfiling();
+    }
+    function isRunning() {
+        return ReactDebugTool_1.isProfiling();
+    }
+    var ReactPerfAnalysis = {
+        getLastMeasurements: getLastMeasurements,
+        getExclusive: getExclusive,
+        getInclusive: getInclusive,
+        getWasted: getWasted,
+        getOperations: getOperations,
+        printExclusive: printExclusive,
+        printInclusive: printInclusive,
+        printWasted: printWasted,
+        printOperations: printOperations,
+        start: start,
+        stop: stop,
+        isRunning: isRunning,
+        printDOM: printDOM,
+        getMeasurementsSummaryMap: getMeasurementsSummaryMap
+    }, ReactPerf = ReactPerfAnalysis, injectInternals = ReactFiberDevToolsHook.injectInternals;
+    ReactGenericBatching_1.injection.injectFiberBatchedUpdates(ReactNativeFiberRenderer.batchedUpdates);
+    var roots = new Map();
+    ReactFiberErrorLogger.injection.injectDialog(ReactNativeFiberErrorDialog_1.showDialog);
+    var ReactNativeFiber = {
+        NativeComponent: ReactNativeComponent_1,
+        findNodeHandle: findNumericNodeHandleFiber,
+        render: function(element, containerTag, callback) {
+            var root = roots.get(containerTag);
+            return root || (root = ReactNativeFiberRenderer.createContainer(containerTag), roots.set(containerTag, root)), 
+            ReactNativeFiberRenderer.updateContainer(element, root, null, callback), ReactNativeFiberRenderer.getPublicRootInstance(root);
+        },
+        unmountComponentAtNode: function(containerTag) {
+            var root = roots.get(containerTag);
+            root && ReactNativeFiberRenderer.updateContainer(null, root, null, function() {
+                roots.delete(containerTag);
+            });
+        },
+        unmountComponentAtNodeAndRemoveContainer: function(containerTag) {
+            ReactNativeFiber.unmountComponentAtNode(containerTag), UIManager.removeRootView(containerTag);
+        },
+        unstable_createPortal: function(children, containerTag) {
+            var key = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : null;
+            return ReactPortal.createPortal(children, containerTag, null, key);
+        },
+        unstable_batchedUpdates: ReactGenericBatching_1.batchedUpdates,
+        flushSync: ReactNativeFiberRenderer.flushSync,
+        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+            NativeMethodsMixin: NativeMethodsMixin_1,
+            ReactGlobalSharedState: ReactGlobalSharedState_1,
+            ReactNativeComponentTree: ReactNativeComponentTree_1,
+            ReactNativePropRegistry: ReactNativePropRegistry_1,
+            TouchHistoryMath: TouchHistoryMath_1,
+            createReactNativeComponentClass: createReactNativeComponentClass,
+            takeSnapshot: takeSnapshot_1
+        }
+    };
+    Object.assign(ReactNativeFiber.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
+        ReactDebugTool: ReactDebugTool_1,
+        ReactPerf: ReactPerf
+    }), injectInternals({
+        findFiberByHostInstance: ReactNativeComponentTree_1.getClosestInstanceFromNode,
+        findHostInstanceByFiber: ReactNativeFiberRenderer.findHostInstance,
+        getInspectorDataForViewTag: ReactNativeFiberInspector.getInspectorDataForViewTag,
+        bundleType: 1,
+        version: ReactVersion
+    });
+    var ReactNativeFiberEntry = ReactNativeFiber;
+    module.exports = ReactNativeFiberEntry;
+}();
diff --git a/Libraries/Renderer/ReactNativeFiber-prod.js b/Libraries/Renderer/ReactNativeFiber-prod.js
index e04904d3e49..34049e24cd1 100644
--- a/Libraries/Renderer/ReactNativeFiber-prod.js
+++ b/Libraries/Renderer/ReactNativeFiber-prod.js
@@ -11,26 +11,22 @@
  */
 "use strict";
 
-var invariant = require("fbjs/lib/invariant"), warning = require("fbjs/lib/warning"), ExceptionsManager = require("ExceptionsManager");
-
-require("InitializeCore");
-
-var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), UIManager = require("UIManager");
-
-require("prop-types/checkPropTypes");
-
-var emptyObject = require("fbjs/lib/emptyObject"), react = require("react"), shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState");
+var invariant = require("fbjs/lib/invariant"), ExceptionsManager = require("ExceptionsManager"), emptyObject = require("fbjs/lib/emptyObject"), react = require("react"), shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState"), UIManager = require("UIManager");
 
 require("deepFreezeAndThrowOnMutationInDev");
 
-var defaultShowDialog = function(capturedError) {
+var warning = require("fbjs/lib/warning");
+
+require("InitializeCore");
+
+var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), defaultShowDialog = function(capturedError) {
     return !0;
 }, showDialog = defaultShowDialog;
 
 function logCapturedError(capturedError) {
     if (!1 !== showDialog(capturedError)) {
-        var _error = capturedError.error;
-        console.error("React caught an error thrown by one of your components.\n\n" + _error.stack);
+        var error = capturedError.error;
+        console.error(error);
     }
 }
 
@@ -43,20 +39,11 @@ var injection = {
 }, logCapturedError_1 = logCapturedError, ReactFiberErrorLogger = {
     injection: injection,
     logCapturedError: logCapturedError_1
-}, caughtError = null, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-    var funcArgs = Array.prototype.slice.call(arguments, 3);
-    try {
-        func.apply(context, funcArgs);
-    } catch (error) {
-        return error;
-    }
-    return null;
-}, rethrowCaughtError = function() {
-    if (caughtError) {
-        var error = caughtError;
-        throw caughtError = null, error;
-    }
 }, ReactErrorUtils = {
+    _caughtError: null,
+    _hasCaughtError: !1,
+    _rethrowError: null,
+    _hasRethrowError: !1,
     injection: {
         injectErrorUtils: function(injectedErrorUtils) {
             invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
@@ -64,14 +51,41 @@ var injection = {
         }
     },
     invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
-        return invokeGuardedCallback.apply(this, arguments);
+        invokeGuardedCallback.apply(ReactErrorUtils, arguments);
     },
     invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
-        var error = ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
-        null !== error && null === caughtError && (caughtError = error);
+        if (ReactErrorUtils.invokeGuardedCallback.apply(this, arguments), ReactErrorUtils.hasCaughtError()) {
+            var error = ReactErrorUtils.clearCaughtError();
+            ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
+        }
     },
     rethrowCaughtError: function() {
-        return rethrowCaughtError.apply(this, arguments);
+        return rethrowCaughtError.apply(ReactErrorUtils, arguments);
+    },
+    hasCaughtError: function() {
+        return ReactErrorUtils._hasCaughtError;
+    },
+    clearCaughtError: function() {
+        if (ReactErrorUtils._hasCaughtError) {
+            var error = ReactErrorUtils._caughtError;
+            return ReactErrorUtils._caughtError = null, ReactErrorUtils._hasCaughtError = !1, 
+            error;
+        }
+        invariant(!1, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
+    }
+}, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+    ReactErrorUtils._hasCaughtError = !1, ReactErrorUtils._caughtError = null;
+    var funcArgs = Array.prototype.slice.call(arguments, 3);
+    try {
+        func.apply(context, funcArgs);
+    } catch (error) {
+        ReactErrorUtils._caughtError = error, ReactErrorUtils._hasCaughtError = !0;
+    }
+}, rethrowCaughtError = function() {
+    if (ReactErrorUtils._hasRethrowError) {
+        var error = ReactErrorUtils._rethrowError;
+        throw ReactErrorUtils._rethrowError = null, ReactErrorUtils._hasRethrowError = !1, 
+        error;
     }
 }, ReactErrorUtils_1 = ReactErrorUtils, ComponentTree, injection$1 = {
     injectComponentTree: function(Injected) {
@@ -157,11 +171,11 @@ function restoreStateOfTarget(target) {
     var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
     if (internalInstance) {
         if ("number" == typeof internalInstance.tag) {
-            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "Fiber needs to be injected to handle a fiber target for controlled " + "events.");
+            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "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.");
             var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
             return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
         }
-        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component."), 
+        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component. " + "This error is likely caused by a bug in React. Please file an issue."), 
         internalInstance.restoreControlledState();
     }
 }
@@ -229,398 +243,22 @@ function ReactNativeFiberErrorDialog(capturedError) {
 
 var showDialog$1 = ReactNativeFiberErrorDialog, ReactNativeFiberErrorDialog_1 = {
     showDialog: showDialog$1
-}, eventPluginOrder = null, namesToPlugins = {};
-
-function recomputePluginOrdering() {
-    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
-        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
-        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
-        !EventPluginRegistry.plugins[pluginIndex]) {
-            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
-            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
-            var publishedEvents = pluginModule.eventTypes;
-            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
-        }
-    }
-}
-
-function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
-    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
-    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-    if (phasedRegistrationNames) {
-        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
-            var phasedRegistrationName = phasedRegistrationNames[phaseName];
-            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
-        }
-        return !0;
-    }
-    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
-    !0);
-}
-
-function publishRegistrationName(registrationName, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
-    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
-}
-
-var EventPluginRegistry = {
-    plugins: [],
-    eventNameDispatchConfigs: {},
-    registrationNameModules: {},
-    registrationNameDependencies: {},
-    possibleRegistrationNames: null,
-    injectEventPluginOrder: function(injectedEventPluginOrder) {
-        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
-        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
-    },
-    injectEventPluginsByName: function(injectedNamesToPlugins) {
-        var isOrderingDirty = !1;
-        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
-            var pluginModule = injectedNamesToPlugins[pluginName];
-            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
-            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
-        }
-        isOrderingDirty && recomputePluginOrdering();
-    }
-}, EventPluginRegistry_1 = EventPluginRegistry;
-
-function accumulateInto(current, next) {
-    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
-    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulateInto_1 = accumulateInto;
-
-function forEachAccumulated(arr, cb, scope) {
-    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
-}
-
-var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
-    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
-}, executeDispatchesAndReleaseSimulated = function(e) {
-    return executeDispatchesAndRelease(e, !0);
-}, executeDispatchesAndReleaseTopLevel = function(e) {
-    return executeDispatchesAndRelease(e, !1);
-};
-
-function isInteractive(tag) {
-    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-    switch (name) {
-      case "onClick":
-      case "onClickCapture":
-      case "onDoubleClick":
-      case "onDoubleClickCapture":
-      case "onMouseDown":
-      case "onMouseDownCapture":
-      case "onMouseMove":
-      case "onMouseMoveCapture":
-      case "onMouseUp":
-      case "onMouseUpCapture":
-        return !(!props.disabled || !isInteractive(type));
-
-      default:
-        return !1;
-    }
-}
-
-var EventPluginHub = {
-    injection: {
-        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
-        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
-    },
-    getListener: function(inst, registrationName) {
-        var listener;
-        if ("number" == typeof inst.tag) {
-            var stateNode = inst.stateNode;
-            if (!stateNode) return null;
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
-            if (!props) return null;
-            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
-        } else {
-            var currentElement = inst._currentElement;
-            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
-            if (!inst._rootNodeID) return null;
-            var _props = currentElement.props;
-            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
-        }
-        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
-        listener;
-    },
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
-            var possiblePlugin = plugins[i];
-            if (possiblePlugin) {
-                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
-            }
-        }
-        return events;
-    },
-    enqueueEvents: function(events) {
-        events && (eventQueue = accumulateInto_1(eventQueue, events));
-    },
-    processEventQueue: function(simulated) {
-        var processingEventQueue = eventQueue;
-        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
-        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
-        ReactErrorUtils_1.rethrowCaughtError();
-    }
-}, EventPluginHub_1 = EventPluginHub, ReactTypeOfWork = {
-    IndeterminateComponent: 0,
-    FunctionalComponent: 1,
-    ClassComponent: 2,
-    HostRoot: 3,
-    HostPortal: 4,
-    HostComponent: 5,
-    HostText: 6,
-    CoroutineComponent: 7,
-    CoroutineHandlerPhase: 8,
-    YieldComponent: 9,
-    Fragment: 10
-}, HostComponent = ReactTypeOfWork.HostComponent;
-
-function getParent(inst) {
-    if (void 0 !== inst._hostParent) return inst._hostParent;
-    if ("number" == typeof inst.tag) {
-        do {
-            inst = inst.return;
-        } while (inst && inst.tag !== HostComponent);
-        if (inst) return inst;
-    }
-    return null;
-}
-
-function getLowestCommonAncestor(instA, instB) {
-    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
-    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
-    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
-    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
-    for (var depth = depthA; depth--; ) {
-        if (instA === instB || instA === instB.alternate) return instA;
-        instA = getParent(instA), instB = getParent(instB);
-    }
-    return null;
-}
-
-function isAncestor(instA, instB) {
-    for (;instB; ) {
-        if (instA === instB || instA === instB.alternate) return !0;
-        instB = getParent(instB);
-    }
-    return !1;
-}
-
-function getParentInstance(inst) {
-    return getParent(inst);
-}
-
-function traverseTwoPhase(inst, fn, arg) {
-    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
-    var i;
-    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
-    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
-}
-
-function traverseEnterLeave(from, to, fn, argFrom, argTo) {
-    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
-    from = getParent(from);
-    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
-    var i;
-    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
-    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
-}
-
-var ReactTreeTraversal = {
-    isAncestor: isAncestor,
-    getLowestCommonAncestor: getLowestCommonAncestor,
-    getParentInstance: getParentInstance,
-    traverseTwoPhase: traverseTwoPhase,
-    traverseEnterLeave: traverseEnterLeave
-}, getListener = EventPluginHub_1.getListener;
-
-function listenerAtPhase(inst, event, propagationPhase) {
-    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
-    return getListener(inst, registrationName);
-}
-
-function accumulateDirectionalDispatches(inst, phase, event) {
-    var listener = listenerAtPhase(inst, event, phase);
-    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-}
-
-function accumulateTwoPhaseDispatchesSingle(event) {
-    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
-}
-
-function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
-    if (event && event.dispatchConfig.phasedRegistrationNames) {
-        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
-        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
-    }
-}
-
-function accumulateDispatches(inst, ignoredDirection, event) {
-    if (inst && event && event.dispatchConfig.registrationName) {
-        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
-        listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-        event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-    }
-}
-
-function accumulateDirectDispatchesSingle(event) {
-    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
-}
-
-function accumulateTwoPhaseDispatches(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
-}
-
-function accumulateTwoPhaseDispatchesSkipTarget(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
-}
-
-function accumulateEnterLeaveDispatches(leave, enter, from, to) {
-    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
-}
-
-function accumulateDirectDispatches(events) {
-    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
-}
-
-var EventPropagators = {
-    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
-    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
-    accumulateDirectDispatches: accumulateDirectDispatches,
-    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
-}, EventPropagators_1 = EventPropagators, oneArgumentPooler = function(copyFieldsFrom) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, copyFieldsFrom), instance;
-    }
-    return new Klass(copyFieldsFrom);
-}, twoArgumentPooler = function(a1, a2) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2), instance;
-    }
-    return new Klass(a1, a2);
-}, threeArgumentPooler = function(a1, a2, a3) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3), instance;
-    }
-    return new Klass(a1, a2, a3);
-}, fourArgumentPooler = function(a1, a2, a3, a4) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3, a4), instance;
-    }
-    return new Klass(a1, a2, a3, a4);
-}, standardReleaser = function(instance) {
-    var Klass = this;
-    invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
-    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
-}, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
-    var NewKlass = CopyConstructor;
-    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
-    NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
-    NewKlass;
-}, PooledClass = {
-    addPoolingTo: addPoolingTo,
-    oneArgumentPooler: oneArgumentPooler,
-    twoArgumentPooler: twoArgumentPooler,
-    threeArgumentPooler: threeArgumentPooler,
-    fourArgumentPooler: fourArgumentPooler
-}, PooledClass_1 = PooledClass, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
-    type: null,
-    target: null,
-    currentTarget: emptyFunction.thatReturnsNull,
-    eventPhase: null,
-    bubbles: null,
-    cancelable: null,
-    timeStamp: function(event) {
-        return event.timeStamp || Date.now();
-    },
-    defaultPrevented: null,
-    isTrusted: null
-};
-
-function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
-    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
-    var Interface = this.constructor.Interface;
-    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
-        var normalize = Interface[propName];
-        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
-    }
-    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
-    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
-    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
-}
-
-Object.assign(SyntheticEvent.prototype, {
-    preventDefault: function() {
-        this.defaultPrevented = !0;
-        var event = this.nativeEvent;
-        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
-        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
-    },
-    stopPropagation: function() {
-        var event = this.nativeEvent;
-        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
-        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
-    },
-    persist: function() {
-        this.isPersistent = emptyFunction.thatReturnsTrue;
-    },
-    isPersistent: emptyFunction.thatReturnsFalse,
-    destructor: function() {
-        var Interface = this.constructor.Interface;
-        for (var propName in Interface) this[propName] = null;
-        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
-    }
-}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
-    var Super = this, E = function() {};
-    E.prototype = Super.prototype;
-    var prototype = new E();
-    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
-    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
-    PooledClass_1.addPoolingTo(Class, PooledClass_1.fourArgumentPooler);
-}, PooledClass_1.addPoolingTo(SyntheticEvent, PooledClass_1.fourArgumentPooler);
-
-var SyntheticEvent_1 = SyntheticEvent, _extends = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
-
-for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
-
-for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
-allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
-
-var ReactNativeBridgeEventPlugin = {
-    eventTypes: _extends({}, customBubblingEventTypes, customDirectEventTypes),
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
-        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
-            if (!directDispatchConfig) return null;
-            EventPropagators_1.accumulateDirectDispatches(event);
-        }
-        return event;
-    }
-}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin, instanceCache = {}, instanceProps = {};
+}, REACT_PORTAL_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.portal") || 60106, createPortal = function(children, containerInfo, implementation) {
+    var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null;
+    return {
+        $$typeof: REACT_PORTAL_TYPE,
+        key: null == key ? null : "" + key,
+        children: children,
+        containerInfo: containerInfo,
+        implementation: implementation
+    };
+}, isPortal = function(object) {
+    return "object" == typeof object && null !== object && object.$$typeof === REACT_PORTAL_TYPE;
+}, REACT_PORTAL_TYPE_1 = REACT_PORTAL_TYPE, ReactPortal = {
+    createPortal: createPortal,
+    isPortal: isPortal,
+    REACT_PORTAL_TYPE: REACT_PORTAL_TYPE_1
+}, instanceCache = {}, instanceProps = {};
 
 function getRenderedHostOrTextFromComponent(component) {
     for (var rendered; rendered = component._renderedComponent; ) component = rendered;
@@ -672,353 +310,7 @@ var ReactNativeComponentTree = {
     uncacheNode: uncacheNode,
     getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
     updateFiberProps: updateFiberProps
-}, ReactNativeComponentTree_1 = ReactNativeComponentTree;
-
-function runEventQueueInBatch(events) {
-    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
-}
-
-var ReactEventEmitterMixin = {
-    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
-    }
-}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
-    tagsStartAt: INITIAL_TAG_COUNT,
-    tagCount: INITIAL_TAG_COUNT,
-    allocateTag: function() {
-        for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
-        var tag = ReactNativeTagHandles.tagCount;
-        return ReactNativeTagHandles.tagCount++, tag;
-    },
-    assertRootTag: function(tag) {
-        invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
-    },
-    reactTagIsNativeTopRootID: function(reactTag) {
-        return reactTag % 10 == 1;
-    }
-}, ReactNativeTagHandles_1 = ReactNativeTagHandles, _extends$1 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
-    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
-    return ret;
-}, removeTouchesAtIndices = function(touches, indices) {
-    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
-        var index = indices[i];
-        rippedOut.push(touches[index]), temp[index] = null;
-    }
-    for (var fillAt = 0, j = 0; j < temp.length; j++) {
-        var cur = temp[j];
-        null !== cur && (temp[fillAt++] = cur);
-    }
-    return temp.length = fillAt, rippedOut;
-}, ReactNativeEventEmitter = _extends$1({}, ReactEventEmitterMixin_1, {
-    registrationNames: EventPluginRegistry_1.registrationNameModules,
-    getListener: EventPluginHub_1.getListener,
-    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
-        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
-        ReactGenericBatching_1.batchedUpdates(function() {
-            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
-        });
-    },
-    receiveEvent: function(tag, topLevelType, nativeEventParam) {
-        var rootNodeID = tag;
-        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
-    },
-    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
-        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
-            var touch = changedTouches[jj];
-            touch.changedTouches = changedTouches, touch.touches = touches;
-            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
-            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt || (rootNodeID = target)), 
-            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
-        }
-    }
-}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
-    onChange: function(from, to, blockNativeResponder) {
-        if (null !== to) {
-            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
-            UIManager.setJSResponder(tag, blockNativeResponder);
-        } else UIManager.clearJSResponder();
-    }
-}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
-    touchHistory: function(nativeEvent) {
-        return null;
-    }
-};
-
-function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-}
-
-SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
-
-var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
-    touchBank: touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0
-};
-
-function timestampForTouch(touch) {
-    return touch.timeStamp || touch.timestamp;
-}
-
-function createTouchRecord(touch) {
-    return {
-        touchActive: !0,
-        startPageX: touch.pageX,
-        startPageY: touch.pageY,
-        startTimeStamp: timestampForTouch(touch),
-        currentPageX: touch.pageX,
-        currentPageY: touch.pageY,
-        currentTimeStamp: timestampForTouch(touch),
-        previousPageX: touch.pageX,
-        previousPageY: touch.pageY,
-        previousTimeStamp: timestampForTouch(touch)
-    };
-}
-
-function resetTouchRecord(touchRecord, touch) {
-    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
-    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
-    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
-    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
-    touchRecord.previousTimeStamp = timestampForTouch(touch);
-}
-
-function getTouchIdentifier(_ref) {
-    var identifier = _ref.identifier;
-    return invariant(null != identifier, "Touch object is missing identifier."), warning(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
-    identifier;
-}
-
-function recordTouchStart(touch) {
-    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
-    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
-    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-}
-
-function recordTouchMove(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function recordTouchEnd(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function printTouch(touch) {
-    return JSON.stringify({
-        identifier: touch.identifier,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        timestamp: timestampForTouch(touch)
-    });
-}
-
-function printTouchBank() {
-    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
-    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
-    printed;
-}
-
-var ResponderTouchHistoryStore = {
-    recordTouchTrack: function(topLevelType, nativeEvent) {
-        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) for (var i = 0; i < touchBank.length; i++) {
-            var touchTrackToCheck = touchBank[i];
-            if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
-                touchHistory.indexOfSingleActiveTouch = i;
-                break;
-            }
-        }
-    },
-    touchHistory: touchHistory
-}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
-
-function accumulate(current, next) {
-    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
-    var oldResponderInst = responderInst;
-    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
-}, eventTypes = {
-    startShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onStartShouldSetResponder",
-            captured: "onStartShouldSetResponderCapture"
-        }
-    },
-    scrollShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onScrollShouldSetResponder",
-            captured: "onScrollShouldSetResponderCapture"
-        }
-    },
-    selectionChangeShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onSelectionChangeShouldSetResponder",
-            captured: "onSelectionChangeShouldSetResponderCapture"
-        }
-    },
-    moveShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onMoveShouldSetResponder",
-            captured: "onMoveShouldSetResponderCapture"
-        }
-    },
-    responderStart: {
-        registrationName: "onResponderStart"
-    },
-    responderMove: {
-        registrationName: "onResponderMove"
-    },
-    responderEnd: {
-        registrationName: "onResponderEnd"
-    },
-    responderRelease: {
-        registrationName: "onResponderRelease"
-    },
-    responderTerminationRequest: {
-        registrationName: "onResponderTerminationRequest"
-    },
-    responderGrant: {
-        registrationName: "onResponderGrant"
-    },
-    responderReject: {
-        registrationName: "onResponderReject"
-    },
-    responderTerminate: {
-        registrationName: "onResponderTerminate"
-    }
-};
-
-function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
-    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
-    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
-    !wantsResponderInst || wantsResponderInst === responderInst) return null;
-    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
-    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
-    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
-    if (responderInst) {
-        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
-        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
-        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
-        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
-        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
-        shouldSwitch) {
-            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
-            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
-            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
-        } else {
-            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
-            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
-            extracted = accumulate_1(extracted, rejectEvent);
-        }
-    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
-    return extracted;
-}
-
-function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
-    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
-}
-
-function noResponderTouches(nativeEvent) {
-    var touches = nativeEvent.touches;
-    if (!touches || 0 === touches.length) return !0;
-    for (var i = 0; i < touches.length; i++) {
-        var activeTouch = touches[i], target = activeTouch.target;
-        if (null !== target && void 0 !== target && 0 !== target) {
-            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
-            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
-        }
-    }
-    return !0;
-}
-
-var ResponderEventPlugin = {
-    _getResponder: function() {
-        return responderInst;
-    },
-    eventTypes: eventTypes,
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
-            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
-            null;
-            trackedTouchCount -= 1;
-        }
-        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
-        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
-        if (incrementalTouch) {
-            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
-            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
-            extracted = accumulate_1(extracted, gesture);
-        }
-        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
-        if (finalTouch) {
-            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
-            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
-            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
-        }
-        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
-        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
-        previousActiveTouches = numberActiveTouches, extracted;
-    },
-    GlobalResponderHandler: null,
-    GlobalInteractionHandler: null,
-    injection: {
-        injectGlobalResponderHandler: function(GlobalResponderHandler) {
-            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
-        },
-        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
-            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
-        }
-    }
-}, ResponderEventPlugin_1 = ResponderEventPlugin;
-
-function inject() {
-    RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
-    EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
-    EventPluginHub_1.injection.injectEventPluginsByName({
-        ResponderEventPlugin: ResponderEventPlugin_1,
-        ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
-    });
-}
-
-var ReactNativeInjection = {
-    inject: inject
-}, REACT_PORTAL_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.portal") || 60106, createPortal = function(children, containerInfo, implementation) {
-    var key = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : null;
-    return {
-        $$typeof: REACT_PORTAL_TYPE,
-        key: null == key ? null : "" + key,
-        children: children,
-        containerInfo: containerInfo,
-        implementation: implementation
-    };
-}, isPortal = function(object) {
-    return "object" == typeof object && null !== object && object.$$typeof === REACT_PORTAL_TYPE;
-}, REACT_PORTAL_TYPE_1 = REACT_PORTAL_TYPE, ReactPortal = {
-    createPortal: createPortal,
-    isPortal: isPortal,
-    REACT_PORTAL_TYPE: REACT_PORTAL_TYPE_1
-}, commonjsGlobal = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {}, ReactFeatureFlags = {
+}, ReactNativeComponentTree_1 = ReactNativeComponentTree, commonjsGlobal = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof self ? self : {}, ReactFeatureFlags = {
     disableNewFiberFeatures: !1,
     enableAsyncSubtreeAPI: !1
 }, ReactFeatureFlags_1 = ReactFeatureFlags, ReactTypeOfSideEffect = {
@@ -1039,6 +331,18 @@ var ReactNativeInjection = {
     HighPriority: 3,
     LowPriority: 4,
     OffscreenPriority: 5
+}, ReactTypeOfWork = {
+    IndeterminateComponent: 0,
+    FunctionalComponent: 1,
+    ClassComponent: 2,
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5,
+    HostText: 6,
+    CoroutineComponent: 7,
+    CoroutineHandlerPhase: 8,
+    YieldComponent: 9,
+    Fragment: 10
 }, CallbackEffect = ReactTypeOfSideEffect.Callback, NoWork = ReactPriorityLevel.NoWork, SynchronousPriority = ReactPriorityLevel.SynchronousPriority, TaskPriority = ReactPriorityLevel.TaskPriority, ClassComponent = ReactTypeOfWork.ClassComponent, HostRoot = ReactTypeOfWork.HostRoot;
 
 function comparePriority(a, b) {
@@ -1249,7 +553,7 @@ var getComponentName_1 = getComponentName$1, ReactInstanceMap = {
     }
 }, ReactInstanceMap_1 = ReactInstanceMap, ReactInternals = react.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, ReactGlobalSharedState = {
     ReactCurrentOwner: ReactInternals.ReactCurrentOwner
-}, ReactGlobalSharedState_1 = ReactGlobalSharedState, HostRoot$2 = ReactTypeOfWork.HostRoot, HostComponent$2 = ReactTypeOfWork.HostComponent, HostText = ReactTypeOfWork.HostText, NoEffect = ReactTypeOfSideEffect.NoEffect, Placement = ReactTypeOfSideEffect.Placement, MOUNTING = 1, MOUNTED = 2, UNMOUNTED = 3;
+}, ReactGlobalSharedState_1 = ReactGlobalSharedState, HostComponent$1 = ReactTypeOfWork.HostComponent, HostRoot$2 = ReactTypeOfWork.HostRoot, HostPortal = ReactTypeOfWork.HostPortal, HostText = ReactTypeOfWork.HostText, NoEffect = ReactTypeOfSideEffect.NoEffect, Placement = ReactTypeOfSideEffect.Placement, MOUNTING = 1, MOUNTED = 2, UNMOUNTED = 3;
 
 function isFiberMountedImpl(fiber) {
     var node = fiber;
@@ -1313,10 +617,10 @@ function findCurrentFiberUsingSlowPath(fiber) {
                     }
                     _child = _child.sibling;
                 }
-                invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "related to the return pointer.");
+                invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "in React related to the return pointer. Please file an issue.");
             }
         }
-        invariant(a.alternate === b, "Return fibers should always be each others' alternates.");
+        invariant(a.alternate === b, "Return fibers should always be each others' alternates. " + "This error is likely caused by a bug in React. Please file an issue.");
     }
     return invariant(a.tag === HostRoot$2, "Unable to find node on an unmounted component."), 
     a.stateNode.current === a ? fiber : alternate;
@@ -1326,7 +630,7 @@ var findCurrentFiberUsingSlowPath_1 = findCurrentFiberUsingSlowPath, findCurrent
     var currentParent = findCurrentFiberUsingSlowPath(parent);
     if (!currentParent) return null;
     for (var node = currentParent; !0; ) {
-        if (node.tag === HostComponent$2 || node.tag === HostText) return node;
+        if (node.tag === HostComponent$1 || node.tag === HostText) return node;
         if (node.child) node.child.return = node, node = node.child; else {
             if (node === currentParent) return null;
             for (;!node.sibling; ) {
@@ -1337,11 +641,27 @@ var findCurrentFiberUsingSlowPath_1 = findCurrentFiberUsingSlowPath, findCurrent
         }
     }
     return null;
+}, findCurrentHostFiberWithNoPortals$1 = function(parent) {
+    var currentParent = findCurrentFiberUsingSlowPath(parent);
+    if (!currentParent) return null;
+    for (var node = currentParent; !0; ) {
+        if (node.tag === HostComponent$1 || node.tag === HostText) return node;
+        if (node.child && node.tag !== HostPortal) node.child.return = node, node = node.child; else {
+            if (node === currentParent) return null;
+            for (;!node.sibling; ) {
+                if (!node.return || node.return === currentParent) return null;
+                node = node.return;
+            }
+            node.sibling.return = node.return, node = node.sibling;
+        }
+    }
+    return null;
 }, ReactFiberTreeReflection = {
     isFiberMounted: isFiberMounted$1,
     isMounted: isMounted,
     findCurrentFiberUsingSlowPath: findCurrentFiberUsingSlowPath_1,
-    findCurrentHostFiber: findCurrentHostFiber$1
+    findCurrentHostFiber: findCurrentHostFiber$1,
+    findCurrentHostFiberWithNoPortals: findCurrentHostFiberWithNoPortals$1
 }, valueStack = [], index = -1, createCursor$1 = function(defaultValue) {
     return {
         current: defaultValue
@@ -1360,12 +680,6 @@ var findCurrentFiberUsingSlowPath_1 = findCurrentFiberUsingSlowPath, findCurrent
     pop: pop$1,
     push: push$1,
     reset: reset
-}, _extends$2 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
 }, isFiberMounted = ReactFiberTreeReflection.isFiberMounted, ClassComponent$1 = ReactTypeOfWork.ClassComponent, HostRoot$1 = ReactTypeOfWork.HostRoot, createCursor = ReactFiberStack.createCursor, pop = ReactFiberStack.pop, push = ReactFiberStack.push, contextStackCursor = createCursor(emptyObject), didPerformWorkStackCursor = createCursor(!1), previousContext = emptyObject;
 
 function getUnmaskedContext(workInProgress) {
@@ -1408,7 +722,7 @@ function popContextProvider(fiber) {
 }
 
 var popContextProvider_1 = popContextProvider, pushTopLevelContextObject = function(fiber, context, didChange) {
-    invariant(null == contextStackCursor.cursor, "Unexpected context found on stack"), 
+    invariant(null == contextStackCursor.cursor, "Unexpected context found on stack. " + "This error is likely caused by a bug in React. Please file an issue."), 
     push(contextStackCursor, context, fiber), push(didPerformWorkStackCursor, didChange, fiber);
 };
 
@@ -1418,29 +732,33 @@ function processChildContext$1(fiber, parentContext, isReconciling) {
     var childContext = void 0;
     childContext = instance.getChildContext();
     for (var contextKey in childContext) invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName_1(fiber) || "Unknown", contextKey);
-    return _extends$2({}, parentContext, childContext);
+    return Object.assign({}, parentContext, childContext);
 }
 
 var processChildContext_1 = processChildContext$1, pushContextProvider = function(workInProgress) {
     if (!isContextProvider$1(workInProgress)) return !1;
     var instance = workInProgress.stateNode, memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
     return previousContext = contextStackCursor.current, push(contextStackCursor, memoizedMergedChildContext, workInProgress), 
-    push(didPerformWorkStackCursor, !1, workInProgress), !0;
-}, invalidateContextProvider = function(workInProgress) {
+    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress), 
+    !0;
+}, invalidateContextProvider = function(workInProgress, didChange) {
     var instance = workInProgress.stateNode;
-    invariant(instance, "Expected to have an instance by this point.");
-    var mergedContext = processChildContext$1(workInProgress, previousContext, !0);
-    instance.__reactInternalMemoizedMergedChildContext = mergedContext, pop(didPerformWorkStackCursor, workInProgress), 
-    pop(contextStackCursor, workInProgress), push(contextStackCursor, mergedContext, workInProgress), 
-    push(didPerformWorkStackCursor, !0, workInProgress);
+    if (invariant(instance, "Expected to have an instance by this point. " + "This error is likely caused by a bug in React. Please file an issue."), 
+    didChange) {
+        var mergedContext = processChildContext$1(workInProgress, previousContext, !0);
+        instance.__reactInternalMemoizedMergedChildContext = mergedContext, pop(didPerformWorkStackCursor, workInProgress), 
+        pop(contextStackCursor, workInProgress), push(contextStackCursor, mergedContext, workInProgress), 
+        push(didPerformWorkStackCursor, didChange, workInProgress);
+    } else pop(didPerformWorkStackCursor, workInProgress), push(didPerformWorkStackCursor, didChange, workInProgress);
 }, resetContext = function() {
     previousContext = emptyObject, contextStackCursor.current = emptyObject, didPerformWorkStackCursor.current = !1;
 }, findCurrentUnmaskedContext$1 = function(fiber) {
-    invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent$1, "Expected subtree parent to be a mounted class component");
+    invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent$1, "Expected subtree parent to be a mounted class component. " + "This error is likely caused by a bug in React. Please file an issue.");
     for (var node = fiber; node.tag !== HostRoot$1; ) {
         if (isContextProvider$1(node)) return node.stateNode.__reactInternalMemoizedMergedChildContext;
         var parent = node.return;
-        invariant(parent, "Found unexpected detached subtree parent"), node = parent;
+        invariant(parent, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue."), 
+        node = parent;
     }
     return node.stateNode.context;
 }, ReactFiberContext = {
@@ -1460,7 +778,7 @@ var processChildContext_1 = processChildContext$1, pushContextProvider = functio
 }, ReactTypeOfInternalContext = {
     NoContext: 0,
     AsyncUpdates: 1
-}, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, ClassComponent$3 = ReactTypeOfWork.ClassComponent, HostRoot$3 = ReactTypeOfWork.HostRoot, HostComponent$3 = ReactTypeOfWork.HostComponent, HostText$1 = ReactTypeOfWork.HostText, HostPortal = ReactTypeOfWork.HostPortal, CoroutineComponent = ReactTypeOfWork.CoroutineComponent, YieldComponent = ReactTypeOfWork.YieldComponent, Fragment = ReactTypeOfWork.Fragment, NoWork$1 = ReactPriorityLevel.NoWork, NoContext = ReactTypeOfInternalContext.NoContext, NoEffect$1 = ReactTypeOfSideEffect.NoEffect, createFiber = function(tag, key, internalContextTag) {
+}, IndeterminateComponent = ReactTypeOfWork.IndeterminateComponent, ClassComponent$3 = ReactTypeOfWork.ClassComponent, HostRoot$3 = ReactTypeOfWork.HostRoot, HostComponent$2 = ReactTypeOfWork.HostComponent, HostText$1 = ReactTypeOfWork.HostText, HostPortal$1 = ReactTypeOfWork.HostPortal, CoroutineComponent = ReactTypeOfWork.CoroutineComponent, YieldComponent = ReactTypeOfWork.YieldComponent, Fragment = ReactTypeOfWork.Fragment, NoWork$1 = ReactPriorityLevel.NoWork, NoContext = ReactTypeOfInternalContext.NoContext, NoEffect$1 = ReactTypeOfSideEffect.NoEffect, createFiber = function(tag, key, internalContextTag) {
     return {
         tag: tag,
         key: key,
@@ -1518,7 +836,7 @@ var createWorkInProgress = function(current, renderPriority) {
 function createFiberFromElementType(type, key, internalContextTag, debugOwner) {
     var fiber = void 0;
     if ("function" == typeof type) fiber = shouldConstruct(type) ? createFiber(ClassComponent$3, key, internalContextTag) : createFiber(IndeterminateComponent, key, internalContextTag), 
-    fiber.type = type; else if ("string" == typeof type) fiber = createFiber(HostComponent$3, key, internalContextTag), 
+    fiber.type = type; else if ("string" == typeof type) fiber = createFiber(HostComponent$2, key, internalContextTag), 
     fiber.type = type; else if ("object" == typeof type && null !== type && "number" == typeof type.tag) fiber = type; else {
         var info = "";
         invariant(!1, "Element type is invalid: expected a string (for built-in components) " + "or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info);
@@ -1527,7 +845,7 @@ function createFiberFromElementType(type, key, internalContextTag, debugOwner) {
 }
 
 var createFiberFromElementType_1 = createFiberFromElementType, createFiberFromHostInstanceForDeletion = function() {
-    var fiber = createFiber(HostComponent$3, null, NoContext);
+    var fiber = createFiber(HostComponent$2, null, NoContext);
     return fiber.type = "DELETED", fiber;
 }, createFiberFromCoroutine = function(coroutine, internalContextTag, priorityLevel) {
     var fiber = createFiber(CoroutineComponent, coroutine.key, internalContextTag);
@@ -1536,7 +854,7 @@ var createFiberFromElementType_1 = createFiberFromElementType, createFiberFromHo
 }, createFiberFromYield = function(yieldNode, internalContextTag, priorityLevel) {
     return createFiber(YieldComponent, null, internalContextTag);
 }, createFiberFromPortal = function(portal, internalContextTag, priorityLevel) {
-    var fiber = createFiber(HostPortal, portal.key, internalContextTag);
+    var fiber = createFiber(HostPortal$1, portal.key, internalContextTag);
     return fiber.pendingProps = portal.children || [], fiber.pendingWorkPriority = priorityLevel, 
     fiber.stateNode = {
         containerInfo: portal.containerInfo,
@@ -1568,18 +886,16 @@ var createFiberFromElementType_1 = createFiberFromElementType, createFiberFromHo
     return uninitializedFiber.stateNode = root, root;
 }, ReactFiberRoot = {
     createFiberRoot: createFiberRoot$1
-}, IndeterminateComponent$1 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent = ReactTypeOfWork.FunctionalComponent, ClassComponent$5 = ReactTypeOfWork.ClassComponent, HostComponent$5 = ReactTypeOfWork.HostComponent;
-
-function describeComponentFrame(name, source, ownerName) {
+}, describeComponentFrame = function(name, source, ownerName) {
     return "\n    in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
-}
+}, IndeterminateComponent$1 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent = ReactTypeOfWork.FunctionalComponent, ClassComponent$5 = ReactTypeOfWork.ClassComponent, HostComponent$4 = ReactTypeOfWork.HostComponent;
 
 function describeFiber(fiber) {
     switch (fiber.tag) {
       case IndeterminateComponent$1:
       case FunctionalComponent:
       case ClassComponent$5:
-      case HostComponent$5:
+      case HostComponent$4:
         var owner = fiber._debugOwner, source = fiber._debugSource, name = getComponentName_1(fiber), ownerName = null;
         return owner && (ownerName = getComponentName_1(owner)), describeComponentFrame(name, source, ownerName);
 
@@ -1597,8 +913,7 @@ function getStackAddendumByWorkInProgressFiber$1(workInProgress) {
 }
 
 var ReactFiberComponentTreeHook = {
-    getStackAddendumByWorkInProgressFiber: getStackAddendumByWorkInProgressFiber$1,
-    describeComponentFrame: describeComponentFrame
+    getStackAddendumByWorkInProgressFiber: getStackAddendumByWorkInProgressFiber$1
 }, REACT_COROUTINE_TYPE$1, REACT_YIELD_TYPE$1;
 
 "function" == typeof Symbol && Symbol.for ? (REACT_COROUTINE_TYPE$1 = Symbol.for("react.coroutine"), 
@@ -1630,7 +945,7 @@ var createCoroutine = function(children, handler, props) {
     isYield: isYield,
     REACT_YIELD_TYPE: REACT_YIELD_TYPE_1,
     REACT_COROUTINE_TYPE: REACT_COROUTINE_TYPE_1
-}, REACT_COROUTINE_TYPE = ReactCoroutine.REACT_COROUTINE_TYPE, REACT_YIELD_TYPE = ReactCoroutine.REACT_YIELD_TYPE, REACT_PORTAL_TYPE$1 = ReactPortal.REACT_PORTAL_TYPE, createWorkInProgress$2 = ReactFiber.createWorkInProgress, createFiberFromElement$1 = ReactFiber.createFiberFromElement, createFiberFromFragment$1 = ReactFiber.createFiberFromFragment, createFiberFromText$1 = ReactFiber.createFiberFromText, createFiberFromCoroutine$1 = ReactFiber.createFiberFromCoroutine, createFiberFromYield$1 = ReactFiber.createFiberFromYield, createFiberFromPortal$1 = ReactFiber.createFiberFromPortal, isArray = Array.isArray, FunctionalComponent$2 = ReactTypeOfWork.FunctionalComponent, ClassComponent$7 = ReactTypeOfWork.ClassComponent, HostText$3 = ReactTypeOfWork.HostText, HostPortal$3 = ReactTypeOfWork.HostPortal, CoroutineComponent$2 = ReactTypeOfWork.CoroutineComponent, YieldComponent$2 = ReactTypeOfWork.YieldComponent, Fragment$2 = ReactTypeOfWork.Fragment, NoEffect$2 = ReactTypeOfSideEffect.NoEffect, Placement$3 = ReactTypeOfSideEffect.Placement, Deletion$1 = ReactTypeOfSideEffect.Deletion, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103;
+}, REACT_COROUTINE_TYPE = ReactCoroutine.REACT_COROUTINE_TYPE, REACT_YIELD_TYPE = ReactCoroutine.REACT_YIELD_TYPE, REACT_PORTAL_TYPE$1 = ReactPortal.REACT_PORTAL_TYPE, createWorkInProgress$2 = ReactFiber.createWorkInProgress, createFiberFromElement$1 = ReactFiber.createFiberFromElement, createFiberFromFragment$1 = ReactFiber.createFiberFromFragment, createFiberFromText$1 = ReactFiber.createFiberFromText, createFiberFromCoroutine$1 = ReactFiber.createFiberFromCoroutine, createFiberFromYield$1 = ReactFiber.createFiberFromYield, createFiberFromPortal$1 = ReactFiber.createFiberFromPortal, isArray = Array.isArray, FunctionalComponent$2 = ReactTypeOfWork.FunctionalComponent, ClassComponent$7 = ReactTypeOfWork.ClassComponent, HostText$3 = ReactTypeOfWork.HostText, HostPortal$4 = ReactTypeOfWork.HostPortal, CoroutineComponent$2 = ReactTypeOfWork.CoroutineComponent, YieldComponent$2 = ReactTypeOfWork.YieldComponent, Fragment$2 = ReactTypeOfWork.Fragment, NoEffect$2 = ReactTypeOfSideEffect.NoEffect, Placement$3 = ReactTypeOfSideEffect.Placement, Deletion$1 = ReactTypeOfSideEffect.Deletion, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103;
 
 function getIteratorFn(maybeIterable) {
     if (null === maybeIterable || void 0 === maybeIterable) return null;
@@ -1640,21 +955,25 @@ function getIteratorFn(maybeIterable) {
 
 function coerceRef(current, element) {
     var mixedRef = element.ref;
-    if (null !== mixedRef && "function" != typeof mixedRef && element._owner) {
-        var owner = element._owner, inst = void 0;
-        if (owner) if ("number" == typeof owner.tag) {
-            var ownerFiber = owner;
-            invariant(ownerFiber.tag === ClassComponent$7, "Stateless function components cannot have refs."), 
-            inst = ownerFiber.stateNode;
-        } else inst = owner.getPublicInstance();
-        invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
-        var stringRef = "" + mixedRef;
-        if (null !== current && null !== current.ref && current.ref._stringRef === stringRef) return current.ref;
-        var ref = function(value) {
-            var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
-            null === value ? delete refs[stringRef] : refs[stringRef] = value;
-        };
-        return ref._stringRef = stringRef, ref;
+    if (null !== mixedRef && "function" != typeof mixedRef) {
+        if (element._owner) {
+            var owner = element._owner, inst = void 0;
+            if (owner) if ("number" == typeof owner.tag) {
+                var ownerFiber = owner;
+                invariant(ownerFiber.tag === ClassComponent$7, "Stateless function components cannot have refs."), 
+                inst = ownerFiber.stateNode;
+            } else inst = owner.getPublicInstance();
+            invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
+            var stringRef = "" + mixedRef;
+            if (null !== current && null !== current.ref && current.ref._stringRef === stringRef) return current.ref;
+            var ref = function(value) {
+                var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
+                null === value ? delete refs[stringRef] : refs[stringRef] = value;
+            };
+            return ref._stringRef = stringRef, ref;
+        }
+        invariant("string" == typeof mixedRef, "Expected ref to be a function or a string."), 
+        invariant(element._owner, "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);
     }
     return mixedRef;
 }
@@ -1744,7 +1063,7 @@ function ChildReconciler(shouldClone, shouldTrackSideEffects) {
         return existing.type = yieldNode.value, existing.return = returnFiber, existing;
     }
     function updatePortal(returnFiber, current, portal, priority) {
-        if (null === current || current.tag !== HostPortal$3 || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
+        if (null === current || current.tag !== HostPortal$4 || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
             var created = createFiberFromPortal$1(portal, returnFiber.internalContextTag, priority);
             return created.return = returnFiber, created;
         }
@@ -1970,7 +1289,7 @@ function ChildReconciler(shouldClone, shouldTrackSideEffects) {
     function reconcileSinglePortal(returnFiber, currentFirstChild, portal, priority) {
         for (var key = portal.key, child = currentFirstChild; null !== child; ) {
             if (child.key === key) {
-                if (child.tag === HostPortal$3 && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
+                if (child.tag === HostPortal$4 && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
                     deleteRemainingChildren(returnFiber, child.sibling);
                     var existing = useFiber(child, priority);
                     return existing.pendingProps = portal.children || [], existing.return = returnFiber, 
@@ -2044,7 +1363,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
     reconcileChildFibersInPlace: reconcileChildFibersInPlace$1,
     mountChildFibersInPlace: mountChildFibersInPlace$1,
     cloneChildFibers: cloneChildFibers$1
-}, Update$1 = ReactTypeOfSideEffect.Update, AsyncUpdates$1 = ReactTypeOfInternalContext.AsyncUpdates, cacheContext$1 = ReactFiberContext.cacheContext, getMaskedContext$2 = ReactFiberContext.getMaskedContext, getUnmaskedContext$2 = ReactFiberContext.getUnmaskedContext, isContextConsumer$1 = ReactFiberContext.isContextConsumer, addUpdate$1 = ReactFiberUpdateQueue.addUpdate, addReplaceUpdate$1 = ReactFiberUpdateQueue.addReplaceUpdate, addForceUpdate$1 = ReactFiberUpdateQueue.addForceUpdate, beginUpdateQueue$2 = ReactFiberUpdateQueue.beginUpdateQueue, _require5$1 = ReactFiberContext, hasContextChanged$2 = _require5$1.hasContextChanged, isMounted$1 = ReactFiberTreeReflection.isMounted, ReactFiberClassComponent = function(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState) {
+}, Update$1 = ReactTypeOfSideEffect.Update, AsyncUpdates$1 = ReactTypeOfInternalContext.AsyncUpdates, cacheContext$1 = ReactFiberContext.cacheContext, getMaskedContext$2 = ReactFiberContext.getMaskedContext, getUnmaskedContext$2 = ReactFiberContext.getUnmaskedContext, isContextConsumer$1 = ReactFiberContext.isContextConsumer, addUpdate$1 = ReactFiberUpdateQueue.addUpdate, addReplaceUpdate$1 = ReactFiberUpdateQueue.addReplaceUpdate, addForceUpdate$1 = ReactFiberUpdateQueue.addForceUpdate, beginUpdateQueue$2 = ReactFiberUpdateQueue.beginUpdateQueue, _require5 = ReactFiberContext, hasContextChanged$2 = _require5.hasContextChanged, isMounted$1 = ReactFiberTreeReflection.isMounted, ReactFiberClassComponent = function(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState) {
     var updater = {
         isMounted: isMounted$1,
         enqueueSetState: function(instance, partialState, callback) {
@@ -2095,7 +1414,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
         invariant(props, "There must be pending props for an initial mount. This error is " + "likely caused by a bug in React. Please file an issue.");
         var unmaskedContext = getUnmaskedContext$2(workInProgress);
         if (instance.props = props, instance.state = state, instance.refs = emptyObject, 
-        instance.context = getMaskedContext$2(workInProgress, unmaskedContext), ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != workInProgress.type && !0 === workInProgress.type.unstable_asyncUpdates && (workInProgress.internalContextTag |= AsyncUpdates$1), 
+        instance.context = getMaskedContext$2(workInProgress, unmaskedContext), ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != workInProgress.type && null != workInProgress.type.prototype && !0 === workInProgress.type.prototype.unstable_isAsyncReactComponent && (workInProgress.internalContextTag |= AsyncUpdates$1), 
         "function" == typeof instance.componentWillMount) {
             callComponentWillMount(workInProgress, instance);
             var updateQueue = workInProgress.updateQueue;
@@ -2127,7 +1446,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
         mountClassInstance: mountClassInstance,
         updateClassInstance: updateClassInstance
     };
-}, mountChildFibersInPlace = ReactChildFiber.mountChildFibersInPlace, reconcileChildFibers = ReactChildFiber.reconcileChildFibers, reconcileChildFibersInPlace = ReactChildFiber.reconcileChildFibersInPlace, cloneChildFibers = ReactChildFiber.cloneChildFibers, beginUpdateQueue$1 = ReactFiberUpdateQueue.beginUpdateQueue, getMaskedContext$1 = ReactFiberContext.getMaskedContext, getUnmaskedContext$1 = ReactFiberContext.getUnmaskedContext, hasContextChanged$1 = ReactFiberContext.hasContextChanged, pushContextProvider$1 = ReactFiberContext.pushContextProvider, pushTopLevelContextObject$1 = ReactFiberContext.pushTopLevelContextObject, invalidateContextProvider$1 = ReactFiberContext.invalidateContextProvider, IndeterminateComponent$2 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$1 = ReactTypeOfWork.FunctionalComponent, ClassComponent$6 = ReactTypeOfWork.ClassComponent, HostRoot$5 = ReactTypeOfWork.HostRoot, HostComponent$6 = ReactTypeOfWork.HostComponent, HostText$2 = ReactTypeOfWork.HostText, HostPortal$2 = ReactTypeOfWork.HostPortal, CoroutineComponent$1 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$1 = ReactTypeOfWork.YieldComponent, Fragment$1 = ReactTypeOfWork.Fragment, NoWork$3 = ReactPriorityLevel.NoWork, OffscreenPriority$1 = ReactPriorityLevel.OffscreenPriority, PerformedWork$1 = ReactTypeOfSideEffect.PerformedWork, Placement$2 = ReactTypeOfSideEffect.Placement, ContentReset$1 = ReactTypeOfSideEffect.ContentReset, Err$1 = ReactTypeOfSideEffect.Err, Ref$1 = ReactTypeOfSideEffect.Ref, ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, ReactFiberBeginWork = function(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext) {
+}, mountChildFibersInPlace = ReactChildFiber.mountChildFibersInPlace, reconcileChildFibers = ReactChildFiber.reconcileChildFibers, reconcileChildFibersInPlace = ReactChildFiber.reconcileChildFibersInPlace, cloneChildFibers = ReactChildFiber.cloneChildFibers, beginUpdateQueue$1 = ReactFiberUpdateQueue.beginUpdateQueue, getMaskedContext$1 = ReactFiberContext.getMaskedContext, getUnmaskedContext$1 = ReactFiberContext.getUnmaskedContext, hasContextChanged$1 = ReactFiberContext.hasContextChanged, pushContextProvider$1 = ReactFiberContext.pushContextProvider, pushTopLevelContextObject$1 = ReactFiberContext.pushTopLevelContextObject, invalidateContextProvider$1 = ReactFiberContext.invalidateContextProvider, IndeterminateComponent$2 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$1 = ReactTypeOfWork.FunctionalComponent, ClassComponent$6 = ReactTypeOfWork.ClassComponent, HostRoot$5 = ReactTypeOfWork.HostRoot, HostComponent$5 = ReactTypeOfWork.HostComponent, HostText$2 = ReactTypeOfWork.HostText, HostPortal$3 = ReactTypeOfWork.HostPortal, CoroutineComponent$1 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$1 = ReactTypeOfWork.YieldComponent, Fragment$1 = ReactTypeOfWork.Fragment, NoWork$3 = ReactPriorityLevel.NoWork, OffscreenPriority$1 = ReactPriorityLevel.OffscreenPriority, PerformedWork$1 = ReactTypeOfSideEffect.PerformedWork, Placement$2 = ReactTypeOfSideEffect.Placement, ContentReset$1 = ReactTypeOfSideEffect.ContentReset, Err$1 = ReactTypeOfSideEffect.Err, Ref$1 = ReactTypeOfSideEffect.Ref, ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, ReactFiberBeginWork = function(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext) {
     var shouldSetTextContent = config.shouldSetTextContent, useSyncScheduling = config.useSyncScheduling, shouldDeprioritizeSubtree = config.shouldDeprioritizeSubtree, pushHostContext = hostContext.pushHostContext, pushHostContainer = hostContext.pushHostContainer, enterHydrationState = hydrationContext.enterHydrationState, resetHydrationState = hydrationContext.resetHydrationState, tryToClaimNextHydratableInstance = hydrationContext.tryToClaimNextHydratableInstance, _ReactFiberClassCompo = ReactFiberClassComponent(scheduleUpdate, getPriorityContext, memoizeProps, memoizeState), adoptClassInstance = _ReactFiberClassCompo.adoptClassInstance, constructClassInstance = _ReactFiberClassCompo.constructClassInstance, mountClassInstance = _ReactFiberClassCompo.mountClassInstance, updateClassInstance = _ReactFiberClassCompo.updateClassInstance;
     function reconcileChildren(current, workInProgress, nextChildren) {
         reconcileChildrenAtPriority(current, workInProgress, nextChildren, workInProgress.pendingWorkPriority);
@@ -2147,11 +1466,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
     }
     function updateFunctionalComponent(current, workInProgress) {
         var fn = workInProgress.type, nextProps = workInProgress.pendingProps, memoizedProps = workInProgress.memoizedProps;
-        if (hasContextChanged$1()) null === nextProps && (nextProps = memoizedProps); else {
-            if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
-            if ("function" == typeof fn.shouldComponentUpdate && !fn.shouldComponentUpdate(memoizedProps, nextProps)) return memoizeProps(workInProgress, nextProps), 
-            bailoutOnAlreadyFinishedWork(current, workInProgress);
-        }
+        if (hasContextChanged$1()) null === nextProps && (nextProps = memoizedProps); else if (null === nextProps || memoizedProps === nextProps) return bailoutOnAlreadyFinishedWork(current, workInProgress);
         var nextChildren, unmaskedContext = getUnmaskedContext$1(workInProgress), context = getMaskedContext$1(workInProgress, unmaskedContext);
         return nextChildren = fn(nextProps, context), workInProgress.effectTag |= PerformedWork$1, 
         reconcileChildren(current, workInProgress, nextChildren), memoizeProps(workInProgress, nextProps), 
@@ -2164,13 +1479,14 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
         finishClassComponent(current, workInProgress, shouldUpdate, hasContext);
     }
     function finishClassComponent(current, workInProgress, shouldUpdate, hasContext) {
-        if (markRef(current, workInProgress), !shouldUpdate) return bailoutOnAlreadyFinishedWork(current, workInProgress);
+        if (markRef(current, workInProgress), !shouldUpdate) return hasContext && invalidateContextProvider$1(workInProgress, !1), 
+        bailoutOnAlreadyFinishedWork(current, workInProgress);
         var instance = workInProgress.stateNode;
         ReactCurrentOwner$2.current = workInProgress;
         var nextChildren = void 0;
         return nextChildren = instance.render(), workInProgress.effectTag |= PerformedWork$1, 
         reconcileChildren(current, workInProgress, nextChildren), memoizeState(workInProgress, instance.state), 
-        memoizeProps(workInProgress, instance.props), hasContext && invalidateContextProvider$1(workInProgress), 
+        memoizeProps(workInProgress, instance.props), hasContext && invalidateContextProvider$1(workInProgress, !0), 
         workInProgress.child;
     }
     function updateHostRoot(current, workInProgress, priorityLevel) {
@@ -2245,7 +1561,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
             pushContextProvider$1(workInProgress);
             break;
 
-          case HostPortal$2:
+          case HostPortal$3:
             pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
         }
         return null;
@@ -2271,7 +1587,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
           case HostRoot$5:
             return updateHostRoot(current, workInProgress, priorityLevel);
 
-          case HostComponent$6:
+          case HostComponent$5:
             return updateHostComponent(current, workInProgress, priorityLevel);
 
           case HostText$2:
@@ -2286,7 +1602,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
           case YieldComponent$1:
             return null;
 
-          case HostPortal$2:
+          case HostPortal$3:
             return updatePortalComponent(current, workInProgress);
 
           case Fragment$1:
@@ -2297,8 +1613,20 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
         }
     }
     function beginFailedWork(current, workInProgress, priorityLevel) {
-        if (invariant(workInProgress.tag === ClassComponent$6 || workInProgress.tag === HostRoot$5, "Invalid type of work. This error is likely caused by a bug in React. " + "Please file an issue."), 
-        workInProgress.effectTag |= Err$1, null === current ? workInProgress.child = null : workInProgress.child !== current.child && (workInProgress.child = current.child), 
+        switch (workInProgress.tag) {
+          case ClassComponent$6:
+            pushContextProvider$1(workInProgress);
+            break;
+
+          case HostRoot$5:
+            var root = workInProgress.stateNode;
+            pushHostContainer(workInProgress, root.containerInfo);
+            break;
+
+          default:
+            invariant(!1, "Invalid type of work. This error is likely caused by a bug in React. " + "Please file an issue.");
+        }
+        if (workInProgress.effectTag |= Err$1, null === current ? workInProgress.child = null : workInProgress.child !== current.child && (workInProgress.child = current.child), 
         workInProgress.pendingWorkPriority === NoWork$3 || workInProgress.pendingWorkPriority > priorityLevel) return bailoutOnLowPriority(current, workInProgress);
         if (workInProgress.firstEffect = null, workInProgress.lastEffect = null, reconcileChildrenAtPriority(current, workInProgress, null, priorityLevel), 
         workInProgress.tag === ClassComponent$6) {
@@ -2311,7 +1639,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
         beginWork: beginWork,
         beginFailedWork: beginFailedWork
     };
-}, reconcileChildFibers$2 = ReactChildFiber.reconcileChildFibers, popContextProvider$2 = ReactFiberContext.popContextProvider, IndeterminateComponent$3 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$3 = ReactTypeOfWork.FunctionalComponent, ClassComponent$8 = ReactTypeOfWork.ClassComponent, HostRoot$6 = ReactTypeOfWork.HostRoot, HostComponent$7 = ReactTypeOfWork.HostComponent, HostText$4 = ReactTypeOfWork.HostText, HostPortal$4 = ReactTypeOfWork.HostPortal, CoroutineComponent$3 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase$1 = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$3 = ReactTypeOfWork.YieldComponent, Fragment$3 = ReactTypeOfWork.Fragment, Placement$4 = ReactTypeOfSideEffect.Placement, Ref$2 = ReactTypeOfSideEffect.Ref, Update$2 = ReactTypeOfSideEffect.Update, OffscreenPriority$2 = ReactPriorityLevel.OffscreenPriority, ReactFiberCompleteWork = function(config, hostContext, hydrationContext) {
+}, reconcileChildFibers$2 = ReactChildFiber.reconcileChildFibers, popContextProvider$2 = ReactFiberContext.popContextProvider, IndeterminateComponent$3 = ReactTypeOfWork.IndeterminateComponent, FunctionalComponent$3 = ReactTypeOfWork.FunctionalComponent, ClassComponent$8 = ReactTypeOfWork.ClassComponent, HostRoot$6 = ReactTypeOfWork.HostRoot, HostComponent$6 = ReactTypeOfWork.HostComponent, HostText$4 = ReactTypeOfWork.HostText, HostPortal$5 = ReactTypeOfWork.HostPortal, CoroutineComponent$3 = ReactTypeOfWork.CoroutineComponent, CoroutineHandlerPhase$1 = ReactTypeOfWork.CoroutineHandlerPhase, YieldComponent$3 = ReactTypeOfWork.YieldComponent, Fragment$3 = ReactTypeOfWork.Fragment, Placement$4 = ReactTypeOfSideEffect.Placement, Ref$2 = ReactTypeOfSideEffect.Ref, Update$2 = ReactTypeOfSideEffect.Update, OffscreenPriority$2 = ReactPriorityLevel.OffscreenPriority, ReactFiberCompleteWork = function(config, hostContext, hydrationContext) {
     var createInstance = config.createInstance, createTextInstance = config.createTextInstance, appendInitialChild = config.appendInitialChild, finalizeInitialChildren = config.finalizeInitialChildren, prepareUpdate = config.prepareUpdate, getRootHostContainer = hostContext.getRootHostContainer, popHostContext = hostContext.popHostContext, getHostContext = hostContext.getHostContext, popHostContainer = hostContext.popHostContainer, prepareToHydrateHostInstance = hydrationContext.prepareToHydrateHostInstance, prepareToHydrateHostTextInstance = hydrationContext.prepareToHydrateHostTextInstance, popHydrationState = hydrationContext.popHydrationState;
     function markUpdate(workInProgress) {
         workInProgress.effectTag |= Update$2;
@@ -2322,7 +1650,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
     function appendAllYields(yields, workInProgress) {
         var node = workInProgress.stateNode;
         for (node && (node.return = workInProgress); null !== node; ) {
-            if (node.tag === HostComponent$7 || node.tag === HostText$4 || node.tag === HostPortal$4) invariant(!1, "A coroutine cannot have host component children."); else if (node.tag === YieldComponent$3) yields.push(node.type); else if (null !== node.child) {
+            if (node.tag === HostComponent$6 || node.tag === HostText$4 || node.tag === HostPortal$5) invariant(!1, "A coroutine cannot have host component children."); else if (node.tag === YieldComponent$3) yields.push(node.type); else if (null !== node.child) {
                 node.child.return = node, node = node.child;
                 continue;
             }
@@ -2345,7 +1673,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
     }
     function appendAllChildren(parent, workInProgress) {
         for (var node = workInProgress.child; null !== node; ) {
-            if (node.tag === HostComponent$7 || node.tag === HostText$4) appendInitialChild(parent, node.stateNode); else if (node.tag === HostPortal$4) ; else if (null !== node.child) {
+            if (node.tag === HostComponent$6 || node.tag === HostText$4) appendInitialChild(parent, node.stateNode); else if (node.tag === HostPortal$5) ; else if (null !== node.child) {
                 node = node.child;
                 continue;
             }
@@ -2373,7 +1701,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
             fiberRoot.pendingContext = null), null !== current && null !== current.child || (popHydrationState(workInProgress), 
             workInProgress.effectTag &= ~Placement$4), null;
 
-          case HostComponent$7:
+          case HostComponent$6:
             popHostContext(workInProgress);
             var rootContainerInstance = getRootHostContainer(), type = workInProgress.type;
             if (null !== current && null != workInProgress.stateNode) {
@@ -2415,7 +1743,7 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
           case Fragment$3:
             return null;
 
-          case HostPortal$4:
+          case HostPortal$5:
             return markUpdate(workInProgress), popHostContainer(workInProgress), null;
 
           case IndeterminateComponent$3:
@@ -2428,28 +1756,46 @@ var reconcileChildFibers$1 = ChildReconciler(!0, !0), reconcileChildFibersInPlac
     return {
         completeWork: completeWork
     };
-}, rendererID = null, injectInternals$1 = null, onCommitRoot$1 = null, onCommitUnmount$1 = null;
+}, warning$11, onCommitFiberRoot = null, onCommitFiberUnmount = null, hasLoggedError = !1;
 
-if ("undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && __REACT_DEVTOOLS_GLOBAL_HOOK__.supportsFiber) {
-    var inject$1 = __REACT_DEVTOOLS_GLOBAL_HOOK__.inject, onCommitFiberRoot = __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberRoot, onCommitFiberUnmount = __REACT_DEVTOOLS_GLOBAL_HOOK__.onCommitFiberUnmount;
-    injectInternals$1 = function(internals) {
-        warning(null == rendererID, "Cannot inject into DevTools twice."), rendererID = inject$1(internals);
-    }, onCommitRoot$1 = function(root) {
-        if (null != rendererID) try {
-            onCommitFiberRoot(rendererID, root);
-        } catch (err) {}
-    }, onCommitUnmount$1 = function(fiber) {
-        if (null != rendererID) try {
-            onCommitFiberUnmount(rendererID, fiber);
-        } catch (err) {}
+function catchErrors(fn) {
+    return function(arg) {
+        try {
+            return fn(arg);
+        } catch (err) {
+            1 || hasLoggedError || (hasLoggedError = !0, warning$11(!1, "React DevTools encountered an error: %s", err));
+        }
     };
 }
 
+function injectInternals$1(internals) {
+    if ("undefined" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+    var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook.supportsFiber) return !0;
+    try {
+        var rendererID = hook.inject(internals);
+        onCommitFiberRoot = catchErrors(function(root) {
+            return hook.onCommitFiberRoot(rendererID, root);
+        }), onCommitFiberUnmount = catchErrors(function(fiber) {
+            return hook.onCommitFiberUnmount(rendererID, fiber);
+        });
+    } catch (err) {}
+    return !0;
+}
+
+function onCommitRoot$1(root) {
+    "function" == typeof onCommitFiberRoot && onCommitFiberRoot(root);
+}
+
+function onCommitUnmount$1(fiber) {
+    "function" == typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
+}
+
 var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCommitUnmount_1 = onCommitUnmount$1, ReactFiberDevToolsHook = {
     injectInternals: injectInternals_1,
     onCommitRoot: onCommitRoot_1,
     onCommitUnmount: onCommitUnmount_1
-}, ClassComponent$9 = ReactTypeOfWork.ClassComponent, HostRoot$7 = ReactTypeOfWork.HostRoot, HostComponent$8 = ReactTypeOfWork.HostComponent, HostText$5 = ReactTypeOfWork.HostText, HostPortal$5 = ReactTypeOfWork.HostPortal, CoroutineComponent$4 = ReactTypeOfWork.CoroutineComponent, commitCallbacks$1 = ReactFiberUpdateQueue.commitCallbacks, onCommitUnmount = ReactFiberDevToolsHook.onCommitUnmount, Placement$5 = ReactTypeOfSideEffect.Placement, Update$3 = ReactTypeOfSideEffect.Update, Callback$1 = ReactTypeOfSideEffect.Callback, ContentReset$2 = ReactTypeOfSideEffect.ContentReset, ReactFiberCommitWork = function(config, captureError) {
+}, ClassComponent$9 = ReactTypeOfWork.ClassComponent, HostRoot$7 = ReactTypeOfWork.HostRoot, HostComponent$7 = ReactTypeOfWork.HostComponent, HostText$5 = ReactTypeOfWork.HostText, HostPortal$6 = ReactTypeOfWork.HostPortal, CoroutineComponent$4 = ReactTypeOfWork.CoroutineComponent, commitCallbacks$1 = ReactFiberUpdateQueue.commitCallbacks, onCommitUnmount = ReactFiberDevToolsHook.onCommitUnmount, Placement$5 = ReactTypeOfSideEffect.Placement, Update$3 = ReactTypeOfSideEffect.Update, Callback$1 = ReactTypeOfSideEffect.Callback, ContentReset$2 = ReactTypeOfSideEffect.ContentReset, ReactFiberCommitWork = function(config, captureError) {
     var commitMount = config.commitMount, commitUpdate = config.commitUpdate, resetTextContent = config.resetTextContent, commitTextUpdate = config.commitTextUpdate, appendChild = config.appendChild, appendChildToContainer = config.appendChildToContainer, insertBefore = config.insertBefore, insertInContainerBefore = config.insertInContainerBefore, removeChild = config.removeChild, removeChildFromContainer = config.removeChildFromContainer, getPublicInstance = config.getPublicInstance;
     function safelyCallComponentWillUnmount(current, instance) {
         try {
@@ -2476,7 +1822,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         invariant(!1, "Expected to find a host parent. This error is likely caused by a bug " + "in React. Please file an issue.");
     }
     function isHostParent(fiber) {
-        return fiber.tag === HostComponent$8 || fiber.tag === HostRoot$7 || fiber.tag === HostPortal$5;
+        return fiber.tag === HostComponent$7 || fiber.tag === HostRoot$7 || fiber.tag === HostPortal$6;
     }
     function getHostSibling(fiber) {
         var node = fiber;
@@ -2485,9 +1831,9 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
                 if (null === node.return || isHostParent(node.return)) return null;
                 node = node.return;
             }
-            for (node.sibling.return = node.return, node = node.sibling; node.tag !== HostComponent$8 && node.tag !== HostText$5; ) {
+            for (node.sibling.return = node.return, node = node.sibling; node.tag !== HostComponent$7 && node.tag !== HostText$5; ) {
                 if (node.effectTag & Placement$5) continue siblings;
-                if (null === node.child || node.tag === HostPortal$5) continue siblings;
+                if (null === node.child || node.tag === HostPortal$6) continue siblings;
                 node.child.return = node, node = node.child;
             }
             if (!(node.effectTag & Placement$5)) return node.stateNode;
@@ -2496,12 +1842,12 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
     function commitPlacement(finishedWork) {
         var parentFiber = getHostParentFiber(finishedWork), parent = void 0, isContainer = void 0;
         switch (parentFiber.tag) {
-          case HostComponent$8:
+          case HostComponent$7:
             parent = parentFiber.stateNode, isContainer = !1;
             break;
 
           case HostRoot$7:
-          case HostPortal$5:
+          case HostPortal$6:
             parent = parentFiber.stateNode.containerInfo, isContainer = !0;
             break;
 
@@ -2510,7 +1856,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         }
         parentFiber.effectTag & ContentReset$2 && (resetTextContent(parent), parentFiber.effectTag &= ~ContentReset$2);
         for (var before = getHostSibling(finishedWork), node = finishedWork; !0; ) {
-            if (node.tag === HostComponent$8 || node.tag === HostText$5) before ? isContainer ? insertInContainerBefore(parent, node.stateNode, before) : insertBefore(parent, node.stateNode, before) : isContainer ? appendChildToContainer(parent, node.stateNode) : appendChild(parent, node.stateNode); else if (node.tag === HostPortal$5) ; else if (null !== node.child) {
+            if (node.tag === HostComponent$7 || node.tag === HostText$5) before ? isContainer ? insertInContainerBefore(parent, node.stateNode, before) : insertBefore(parent, node.stateNode, before) : isContainer ? appendChildToContainer(parent, node.stateNode) : appendChild(parent, node.stateNode); else if (node.tag === HostPortal$6) ; else if (null !== node.child) {
                 node.child.return = node, node = node.child;
                 continue;
             }
@@ -2523,7 +1869,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         }
     }
     function commitNestedUnmounts(root) {
-        for (var node = root; !0; ) if (commitUnmount(node), null === node.child || node.tag === HostPortal$5) {
+        for (var node = root; !0; ) if (commitUnmount(node), null === node.child || node.tag === HostPortal$6) {
             if (node === root) return;
             for (;null === node.sibling; ) {
                 if (null === node.return || node.return === root) return;
@@ -2539,12 +1885,12 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
                 findParent: for (;!0; ) {
                     switch (invariant(null !== parent, "Expected to find a host parent. This error is likely caused by " + "a bug in React. Please file an issue."), 
                     parent.tag) {
-                      case HostComponent$8:
+                      case HostComponent$7:
                         currentParent = parent.stateNode, currentParentIsContainer = !1;
                         break findParent;
 
                       case HostRoot$7:
-                      case HostPortal$5:
+                      case HostPortal$6:
                         currentParent = parent.stateNode.containerInfo, currentParentIsContainer = !0;
                         break findParent;
                     }
@@ -2552,8 +1898,8 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
                 }
                 currentParentIsValid = !0;
             }
-            if (node.tag === HostComponent$8 || node.tag === HostText$5) commitNestedUnmounts(node), 
-            currentParentIsContainer ? removeChildFromContainer(currentParent, node.stateNode) : removeChild(currentParent, node.stateNode); else if (node.tag === HostPortal$5) {
+            if (node.tag === HostComponent$7 || node.tag === HostText$5) commitNestedUnmounts(node), 
+            currentParentIsContainer ? removeChildFromContainer(currentParent, node.stateNode) : removeChild(currentParent, node.stateNode); else if (node.tag === HostPortal$6) {
                 if (currentParent = node.stateNode.containerInfo, null !== node.child) {
                     node.child.return = node, node = node.child;
                     continue;
@@ -2565,7 +1911,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             if (node === current) return;
             for (;null === node.sibling; ) {
                 if (null === node.return || node.return === current) return;
-                node = node.return, node.tag === HostPortal$5 && (currentParentIsValid = !1);
+                node = node.return, node.tag === HostPortal$6 && (currentParentIsValid = !1);
             }
             node.sibling.return = node.return, node = node.sibling;
         }
@@ -2581,13 +1927,13 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             var instance = current.stateNode;
             return void ("function" == typeof instance.componentWillUnmount && safelyCallComponentWillUnmount(current, instance));
 
-          case HostComponent$8:
+          case HostComponent$7:
             return void safelyDetachRef(current);
 
           case CoroutineComponent$4:
             return void commitNestedUnmounts(current.stateNode);
 
-          case HostPortal$5:
+          case HostPortal$6:
             return void unmountHostComponents(current);
         }
     }
@@ -2596,7 +1942,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
           case ClassComponent$9:
             return;
 
-          case HostComponent$8:
+          case HostComponent$7:
             var instance = finishedWork.stateNode;
             if (null != instance) {
                 var newProps = finishedWork.memoizedProps, oldProps = null !== current ? current.memoizedProps : newProps, type = finishedWork.type, updatePayload = finishedWork.updateQueue;
@@ -2610,7 +1956,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             return void commitTextUpdate(textInstance, oldText, newText);
 
           case HostRoot$7:
-          case HostPortal$5:
+          case HostPortal$6:
             return;
 
           default:
@@ -2635,7 +1981,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             }
             return;
 
-          case HostComponent$8:
+          case HostComponent$7:
             var _instance2 = finishedWork.stateNode;
             if (null === current && finishedWork.effectTag & Update$3) {
                 var type = finishedWork.type, props = finishedWork.memoizedProps;
@@ -2644,7 +1990,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             return;
 
           case HostText$5:
-          case HostPortal$5:
+          case HostPortal$6:
             return;
 
           default:
@@ -2656,7 +2002,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         if (null !== ref) {
             var instance = finishedWork.stateNode;
             switch (finishedWork.tag) {
-              case HostComponent$8:
+              case HostComponent$7:
                 ref(getPublicInstance(instance));
                 break;
 
@@ -2717,7 +2063,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         pushHostContext: pushHostContext,
         resetHostContainer: resetHostContainer
     };
-}, HostComponent$9 = ReactTypeOfWork.HostComponent, HostText$6 = ReactTypeOfWork.HostText, HostRoot$8 = ReactTypeOfWork.HostRoot, Deletion$2 = ReactTypeOfSideEffect.Deletion, Placement$6 = ReactTypeOfSideEffect.Placement, createFiberFromHostInstanceForDeletion$1 = ReactFiber.createFiberFromHostInstanceForDeletion, ReactFiberHydrationContext = function(config) {
+}, HostComponent$8 = ReactTypeOfWork.HostComponent, HostText$6 = ReactTypeOfWork.HostText, HostRoot$8 = ReactTypeOfWork.HostRoot, Deletion$2 = ReactTypeOfSideEffect.Deletion, Placement$6 = ReactTypeOfSideEffect.Placement, createFiberFromHostInstanceForDeletion$1 = ReactFiber.createFiberFromHostInstanceForDeletion, ReactFiberHydrationContext = function(config) {
     var shouldSetTextContent = config.shouldSetTextContent, canHydrateInstance = config.canHydrateInstance, canHydrateTextInstance = config.canHydrateTextInstance, getNextHydratableSibling = config.getNextHydratableSibling, getFirstHydratableChild = config.getFirstHydratableChild, hydrateInstance = config.hydrateInstance, hydrateTextInstance = config.hydrateTextInstance, didNotHydrateInstance = config.didNotHydrateInstance, didNotFindHydratableInstance = config.didNotFindHydratableInstance, didNotFindHydratableTextInstance = config.didNotFindHydratableTextInstance;
     if (!(canHydrateInstance && canHydrateTextInstance && getNextHydratableSibling && getFirstHydratableChild && hydrateInstance && hydrateTextInstance && didNotHydrateInstance && didNotFindHydratableInstance && didNotFindHydratableTextInstance)) return {
         enterHydrationState: function() {
@@ -2726,10 +2072,10 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         resetHydrationState: function() {},
         tryToClaimNextHydratableInstance: function() {},
         prepareToHydrateHostInstance: function() {
-            invariant(!1, "React bug.");
+            invariant(!1, "Expected prepareToHydrateHostInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
         },
         prepareToHydrateHostTextInstance: function() {
-            invariant(!1, "React bug.");
+            invariant(!1, "Expected prepareToHydrateHostTextInstance() to never be called. " + "This error is likely caused by a bug in React. Please file an issue.");
         },
         popHydrationState: function(fiber) {
             return !1;
@@ -2752,7 +2098,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
     }
     function canHydrate(fiber, nextInstance) {
         switch (fiber.tag) {
-          case HostComponent$9:
+          case HostComponent$8:
             var type = fiber.type, props = fiber.pendingProps;
             return canHydrateInstance(nextInstance, type, props);
 
@@ -2786,14 +2132,14 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         return hydrateTextInstance(textInstance, fiber.memoizedProps, fiber);
     }
     function popToNextHostParent(fiber) {
-        for (var parent = fiber.return; null !== parent && parent.tag !== HostComponent$9 && parent.tag !== HostRoot$8; ) parent = parent.return;
+        for (var parent = fiber.return; null !== parent && parent.tag !== HostComponent$8 && parent.tag !== HostRoot$8; ) parent = parent.return;
         hydrationParentFiber = parent;
     }
     function popHydrationState(fiber) {
         if (fiber !== hydrationParentFiber) return !1;
         if (!isHydrating) return popToNextHostParent(fiber), isHydrating = !0, !1;
         var type = fiber.type;
-        if (fiber.tag !== HostComponent$9 || "head" !== type && "body" !== type && !shouldSetTextContent(type, fiber.memoizedProps)) for (var nextInstance = nextHydratableInstance; nextInstance; ) deleteHydratableInstance(fiber, nextInstance), 
+        if (fiber.tag !== HostComponent$8 || "head" !== type && "body" !== type && !shouldSetTextContent(type, fiber.memoizedProps)) for (var nextInstance = nextHydratableInstance; nextInstance; ) deleteHydratableInstance(fiber, nextInstance), 
         nextInstance = getNextHydratableSibling(nextInstance);
         return popToNextHostParent(fiber), nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null, 
         !0;
@@ -2809,12 +2155,12 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         prepareToHydrateHostTextInstance: prepareToHydrateHostTextInstance,
         popHydrationState: popHydrationState
     };
-}, popContextProvider$1 = ReactFiberContext.popContextProvider, reset$1 = ReactFiberStack.reset, getStackAddendumByWorkInProgressFiber = ReactFiberComponentTreeHook.getStackAddendumByWorkInProgressFiber, logCapturedError$1 = ReactFiberErrorLogger.logCapturedError, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, createWorkInProgress$1 = ReactFiber.createWorkInProgress, largerPriority$1 = ReactFiber.largerPriority, onCommitRoot = ReactFiberDevToolsHook.onCommitRoot, NoWork$2 = ReactPriorityLevel.NoWork, SynchronousPriority$1 = ReactPriorityLevel.SynchronousPriority, TaskPriority$1 = ReactPriorityLevel.TaskPriority, HighPriority = ReactPriorityLevel.HighPriority, LowPriority = ReactPriorityLevel.LowPriority, OffscreenPriority = ReactPriorityLevel.OffscreenPriority, AsyncUpdates = ReactTypeOfInternalContext.AsyncUpdates, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement$1 = ReactTypeOfSideEffect.Placement, Update = ReactTypeOfSideEffect.Update, PlacementAndUpdate = ReactTypeOfSideEffect.PlacementAndUpdate, Deletion = ReactTypeOfSideEffect.Deletion, ContentReset = ReactTypeOfSideEffect.ContentReset, Callback = ReactTypeOfSideEffect.Callback, Err = ReactTypeOfSideEffect.Err, Ref = ReactTypeOfSideEffect.Ref, HostRoot$4 = ReactTypeOfWork.HostRoot, HostComponent$4 = ReactTypeOfWork.HostComponent, HostPortal$1 = ReactTypeOfWork.HostPortal, ClassComponent$4 = ReactTypeOfWork.ClassComponent, getUpdatePriority$1 = ReactFiberUpdateQueue.getUpdatePriority, _require14 = ReactFiberContext, resetContext$1 = _require14.resetContext, ReactFiberInstrumentation$1, timeHeuristicForUnitOfWork = 1, ReactFiberScheduler = function(config) {
-    var hostContext = ReactFiberHostContext(config), hydrationContext = ReactFiberHydrationContext(config), popHostContainer = hostContext.popHostContainer, popHostContext = hostContext.popHostContext, resetHostContainer = hostContext.resetHostContainer, _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext), beginWork = _ReactFiberBeginWork.beginWork, beginFailedWork = _ReactFiberBeginWork.beginFailedWork, _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, hydrationContext), completeWork = _ReactFiberCompleteWo.completeWork, _ReactFiberCommitWork = ReactFiberCommitWork(config, captureError), commitPlacement = _ReactFiberCommitWork.commitPlacement, commitDeletion = _ReactFiberCommitWork.commitDeletion, commitWork = _ReactFiberCommitWork.commitWork, commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles, commitAttachRef = _ReactFiberCommitWork.commitAttachRef, commitDetachRef = _ReactFiberCommitWork.commitDetachRef, scheduleDeferredCallback = config.scheduleDeferredCallback, useSyncScheduling = config.useSyncScheduling, prepareForCommit = config.prepareForCommit, resetAfterCommit = config.resetAfterCommit, priorityContext = NoWork$2, priorityContextBeforeReconciliation = NoWork$2, isPerformingWork = !1, deadlineHasExpired = !1, isBatchingUpdates = !1, isUnbatchingUpdates = !1, nextUnitOfWork = null, nextPriorityLevel = NoWork$2, nextEffect = null, pendingCommit = null, nextScheduledRoot = null, lastScheduledRoot = null, isCallbackScheduled = !1, capturedErrors = null, failedBoundaries = null, commitPhaseBoundaries = null, firstUncaughtError = null, fatalError = null, isCommitting = !1, isUnmounting = !1;
+}, popContextProvider$1 = ReactFiberContext.popContextProvider, reset$1 = ReactFiberStack.reset, getStackAddendumByWorkInProgressFiber = ReactFiberComponentTreeHook.getStackAddendumByWorkInProgressFiber, logCapturedError$1 = ReactFiberErrorLogger.logCapturedError, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, createWorkInProgress$1 = ReactFiber.createWorkInProgress, largerPriority$1 = ReactFiber.largerPriority, onCommitRoot = ReactFiberDevToolsHook.onCommitRoot, NoWork$2 = ReactPriorityLevel.NoWork, SynchronousPriority$1 = ReactPriorityLevel.SynchronousPriority, TaskPriority$1 = ReactPriorityLevel.TaskPriority, HighPriority = ReactPriorityLevel.HighPriority, LowPriority = ReactPriorityLevel.LowPriority, OffscreenPriority = ReactPriorityLevel.OffscreenPriority, AsyncUpdates = ReactTypeOfInternalContext.AsyncUpdates, PerformedWork = ReactTypeOfSideEffect.PerformedWork, Placement$1 = ReactTypeOfSideEffect.Placement, Update = ReactTypeOfSideEffect.Update, PlacementAndUpdate = ReactTypeOfSideEffect.PlacementAndUpdate, Deletion = ReactTypeOfSideEffect.Deletion, ContentReset = ReactTypeOfSideEffect.ContentReset, Callback = ReactTypeOfSideEffect.Callback, Err = ReactTypeOfSideEffect.Err, Ref = ReactTypeOfSideEffect.Ref, HostRoot$4 = ReactTypeOfWork.HostRoot, HostComponent$3 = ReactTypeOfWork.HostComponent, HostPortal$2 = ReactTypeOfWork.HostPortal, ClassComponent$4 = ReactTypeOfWork.ClassComponent, getUpdatePriority$1 = ReactFiberUpdateQueue.getUpdatePriority, _require14 = ReactFiberContext, resetContext$1 = _require14.resetContext, ReactFiberInstrumentation$1, timeHeuristicForUnitOfWork = 1, ReactFiberScheduler = function(config) {
+    var hostContext = ReactFiberHostContext(config), hydrationContext = ReactFiberHydrationContext(config), popHostContainer = hostContext.popHostContainer, popHostContext = hostContext.popHostContext, resetHostContainer = hostContext.resetHostContainer, _ReactFiberBeginWork = ReactFiberBeginWork(config, hostContext, hydrationContext, scheduleUpdate, getPriorityContext), beginWork = _ReactFiberBeginWork.beginWork, beginFailedWork = _ReactFiberBeginWork.beginFailedWork, _ReactFiberCompleteWo = ReactFiberCompleteWork(config, hostContext, hydrationContext), completeWork = _ReactFiberCompleteWo.completeWork, _ReactFiberCommitWork = ReactFiberCommitWork(config, captureError), commitPlacement = _ReactFiberCommitWork.commitPlacement, commitDeletion = _ReactFiberCommitWork.commitDeletion, commitWork = _ReactFiberCommitWork.commitWork, commitLifeCycles = _ReactFiberCommitWork.commitLifeCycles, commitAttachRef = _ReactFiberCommitWork.commitAttachRef, commitDetachRef = _ReactFiberCommitWork.commitDetachRef, scheduleDeferredCallback = config.scheduleDeferredCallback, useSyncScheduling = config.useSyncScheduling, prepareForCommit = config.prepareForCommit, resetAfterCommit = config.resetAfterCommit, priorityContext = NoWork$2, isPerformingWork = !1, deadlineHasExpired = !1, isBatchingUpdates = !1, isUnbatchingUpdates = !1, nextUnitOfWork = null, nextPriorityLevel = NoWork$2, nextEffect = null, pendingCommit = null, nextScheduledRoot = null, lastScheduledRoot = null, isCallbackScheduled = !1, capturedErrors = null, failedBoundaries = null, commitPhaseBoundaries = null, firstUncaughtError = null, didFatal = !1, isCommitting = !1, isUnmounting = !1, NESTED_UPDATE_LIMIT = 1e3, nestedUpdateCount = 0;
     function resetContextStack() {
         reset$1(), resetContext$1(), resetHostContainer();
     }
-    function findNextUnitOfWork() {
+    function resetNextUnitOfWork() {
         for (;null !== nextScheduledRoot && nextScheduledRoot.current.pendingWorkPriority === NoWork$2; ) {
             nextScheduledRoot.isScheduled = !1;
             var next = nextScheduledRoot.nextScheduledRoot;
@@ -2824,9 +2170,9 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         }
         for (var root = nextScheduledRoot, highestPriorityRoot = null, highestPriorityLevel = NoWork$2; null !== root; ) root.current.pendingWorkPriority !== NoWork$2 && (highestPriorityLevel === NoWork$2 || highestPriorityLevel > root.current.pendingWorkPriority) && (highestPriorityLevel = root.current.pendingWorkPriority, 
         highestPriorityRoot = root), root = root.nextScheduledRoot;
-        return null !== highestPriorityRoot ? (nextPriorityLevel = highestPriorityLevel, 
-        priorityContext = nextPriorityLevel, resetContextStack(), createWorkInProgress$1(highestPriorityRoot.current, highestPriorityLevel)) : (nextPriorityLevel = NoWork$2, 
-        null);
+        if (null !== highestPriorityRoot) return nextPriorityLevel = highestPriorityLevel, 
+        resetContextStack(), void (nextUnitOfWork = createWorkInProgress$1(highestPriorityRoot.current, highestPriorityLevel));
+        nextPriorityLevel = NoWork$2, nextUnitOfWork = null;
     }
     function commitAllHostEffects() {
         for (;null !== nextEffect; ) {
@@ -2873,36 +2219,35 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         isCommitting = !0, pendingCommit = null;
         var root = finishedWork.stateNode;
         invariant(root.current !== finishedWork, "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."), 
+        nextPriorityLevel !== SynchronousPriority$1 && nextPriorityLevel !== TaskPriority$1 || nestedUpdateCount++, 
         ReactCurrentOwner$1.current = null;
-        var previousPriorityContext = priorityContext;
-        priorityContext = TaskPriority$1;
         var firstEffect = void 0;
         for (finishedWork.effectTag > PerformedWork ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, 
         firstEffect = finishedWork.firstEffect) : firstEffect = finishedWork : firstEffect = finishedWork.firstEffect, 
         prepareForCommit(), nextEffect = firstEffect; null !== nextEffect; ) {
-            var _error = null;
+            var didError = !1, _error = void 0;
             try {
                 commitAllHostEffects();
             } catch (e) {
-                _error = e;
+                didError = !0, _error = e;
             }
-            null !== _error && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
+            didError && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
             captureError(nextEffect, _error), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
         }
         for (resetAfterCommit(), root.current = finishedWork, nextEffect = firstEffect; null !== nextEffect; ) {
-            var _error2 = null;
+            var _didError = !1, _error2 = void 0;
             try {
                 commitAllLifeCycles();
             } catch (e) {
-                _error2 = e;
+                _didError = !0, _error2 = e;
             }
-            null !== _error2 && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
+            _didError && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue."), 
             captureError(nextEffect, _error2), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
         }
         isCommitting = !1, "function" == typeof onCommitRoot && onCommitRoot(finishedWork.stateNode), 
         !1 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCommitWork(finishedWork), 
         commitPhaseBoundaries && (commitPhaseBoundaries.forEach(scheduleErrorRecovery), 
-        commitPhaseBoundaries = null), priorityContext = previousPriorityContext;
+        commitPhaseBoundaries = null), resetNextUnitOfWork();
     }
     function resetWorkPriority(workInProgress, renderPriority) {
         if (!(workInProgress.pendingWorkPriority !== NoWork$2 && workInProgress.pendingWorkPriority > renderPriority)) {
@@ -2925,8 +2270,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             }
             if (!1 && ReactFiberInstrumentation$1.debugTool && ReactFiberInstrumentation$1.debugTool.onCompleteWork(workInProgress), 
             null !== siblingFiber) return siblingFiber;
-            if (null === returnFiber) return nextPriorityLevel < HighPriority ? commitAllWork(workInProgress) : pendingCommit = workInProgress, 
-            null;
+            if (null === returnFiber) return pendingCommit = workInProgress, null;
             workInProgress = returnFiber;
         }
         return null;
@@ -2943,87 +2287,99 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         null === next && (next = completeUnitOfWork(workInProgress)), ReactCurrentOwner$1.current = null, 
         next;
     }
-    function clearErrors() {
-        for (null === nextUnitOfWork && (nextUnitOfWork = findNextUnitOfWork()); null !== capturedErrors && capturedErrors.size && null !== nextUnitOfWork && nextPriorityLevel !== NoWork$2 && nextPriorityLevel <= TaskPriority$1; ) null === (nextUnitOfWork = hasCapturedError(nextUnitOfWork) ? performFailedUnitOfWork(nextUnitOfWork) : performUnitOfWork(nextUnitOfWork)) && (nextUnitOfWork = findNextUnitOfWork());
-    }
-    function workLoopAsync(minPriorityLevel, deadline) {
-        for (;null !== nextUnitOfWork && !deadlineHasExpired; ) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
-            if (null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && null !== pendingCommit) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
-                if (commitAllWork(pendingCommit), nextUnitOfWork = findNextUnitOfWork(), clearErrors(), 
-                nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel < HighPriority) break;
-            } else deadlineHasExpired = !0;
-        } else deadlineHasExpired = !0;
-    }
-    function workLoopSync(minPriorityLevel) {
-        for (;null !== nextUnitOfWork && !(null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && (nextUnitOfWork = findNextUnitOfWork(), 
-        clearErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel > TaskPriority$1)); ) ;
-    }
-    function workLoop(minPriorityLevel, deadline) {
-        clearErrors(), null === nextUnitOfWork && (nextUnitOfWork = findNextUnitOfWork()), 
-        nextPriorityLevel !== NoWork$2 && nextPriorityLevel <= minPriorityLevel && (nextPriorityLevel <= TaskPriority$1 ? workLoopSync(minPriorityLevel) : null !== deadline && workLoopAsync(minPriorityLevel, deadline));
-    }
     function performDeferredWork(deadline) {
         performWork(OffscreenPriority, deadline);
     }
-    function performWork(minPriorityLevel, deadline) {
-        invariant(!isPerformingWork, "performWork was called recursively. This error is likely caused " + "by a bug in React. Please file an issue."), 
-        isPerformingWork = !0;
-        for (var hasRemainingAsyncWork = !1; null === fatalError; ) {
-            null === pendingCommit || deadlineHasExpired || commitAllWork(pendingCommit), priorityContextBeforeReconciliation = priorityContext;
-            var _error3 = null;
-            try {
-                workLoop(minPriorityLevel, deadline);
-            } catch (e) {
-                _error3 = e;
-            }
-            if (priorityContext = priorityContextBeforeReconciliation, null === _error3) {
+    function handleCommitPhaseErrors() {
+        if (null !== capturedErrors && capturedErrors.size > 0 && nextPriorityLevel === TaskPriority$1) for (;null !== nextUnitOfWork && (null !== (nextUnitOfWork = hasCapturedError(nextUnitOfWork) ? performFailedUnitOfWork(nextUnitOfWork) : performUnitOfWork(nextUnitOfWork)) || (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+        priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+        null !== capturedErrors && 0 !== capturedErrors.size && nextPriorityLevel === TaskPriority$1)); ) ;
+    }
+    function workLoop(minPriorityLevel, deadline) {
+        if (null !== pendingCommit ? (priorityContext = TaskPriority$1, commitAllWork(pendingCommit), 
+        handleCommitPhaseErrors()) : null === nextUnitOfWork && resetNextUnitOfWork(), !(nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel)) {
+            priorityContext = nextPriorityLevel;
+            loop: do {
+                if (nextPriorityLevel <= TaskPriority$1) for (;null !== nextUnitOfWork && !(null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork)) && (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+                priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+                handleCommitPhaseErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel > TaskPriority$1)); ) ; else if (null !== deadline) for (;null !== nextUnitOfWork && !deadlineHasExpired; ) if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+                    if (null === (nextUnitOfWork = performUnitOfWork(nextUnitOfWork))) if (invariant(null !== pendingCommit, "Should have a pending commit. This error is likely caused by " + "a bug in React. Please file an issue."), 
+                    deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+                        if (priorityContext = TaskPriority$1, commitAllWork(pendingCommit), priorityContext = nextPriorityLevel, 
+                        handleCommitPhaseErrors(), nextPriorityLevel === NoWork$2 || nextPriorityLevel > minPriorityLevel || nextPriorityLevel < HighPriority) break;
+                    } else deadlineHasExpired = !0;
+                } else deadlineHasExpired = !0;
                 switch (nextPriorityLevel) {
                   case SynchronousPriority$1:
                   case TaskPriority$1:
-                    if (nextPriorityLevel <= minPriorityLevel) continue;
-                    break;
+                    if (nextPriorityLevel <= minPriorityLevel) continue loop;
+                    break loop;
 
                   case HighPriority:
                   case LowPriority:
                   case OffscreenPriority:
-                    if (null === deadline) hasRemainingAsyncWork = !0; else {
-                        if (!deadlineHasExpired && nextPriorityLevel <= minPriorityLevel) continue;
-                        hasRemainingAsyncWork = !0;
-                    }
-                    break;
+                    if (null === deadline) break loop;
+                    if (!deadlineHasExpired && nextPriorityLevel <= minPriorityLevel) continue loop;
+                    break loop;
 
                   case NoWork$2:
-                    break;
+                    break loop;
 
                   default:
-                    invariant(!1, "Switch statement should be exhuastive.");
+                    invariant(!1, "Switch statement should be exhuastive. " + "This error is likely caused by a bug in React. Please file an issue.");
                 }
+            } while (!0);
+        }
+    }
+    function performWorkCatchBlock(failedWork, boundary, minPriorityLevel, deadline) {
+        unwindContexts(failedWork, boundary), nextUnitOfWork = performFailedUnitOfWork(boundary), 
+        workLoop(minPriorityLevel, deadline);
+    }
+    function performWork(minPriorityLevel, deadline) {
+        invariant(!isPerformingWork, "performWork was called recursively. This error is likely caused " + "by a bug in React. Please file an issue."), 
+        isPerformingWork = !0, nestedUpdateCount = 0;
+        var previousPriorityContext = priorityContext, didError = !1, error = null;
+        try {
+            workLoop(minPriorityLevel, deadline);
+        } catch (e) {
+            didError = !0, error = e;
+        }
+        for (;didError; ) {
+            if (didFatal) {
+                firstUncaughtError = error;
                 break;
             }
             var failedWork = nextUnitOfWork;
-            if (null === failedWork) null === fatalError && (fatalError = _error3); else {
-                var maybeBoundary = captureError(failedWork, _error3);
-                if (null !== maybeBoundary) {
-                    var boundary = maybeBoundary;
-                    beginFailedWork(boundary.alternate, boundary, nextPriorityLevel), unwindContexts(failedWork, boundary), 
-                    nextUnitOfWork = completeUnitOfWork(boundary);
+            if (null !== failedWork) {
+                var boundary = captureError(failedWork, error);
+                if (invariant(null !== boundary, "Should have found an error boundary. This error is likely " + "caused by a bug in React. Please file an issue."), 
+                !didFatal) {
+                    didError = !1, error = null;
+                    try {
+                        performWorkCatchBlock(failedWork, boundary, minPriorityLevel, deadline), error = null;
+                    } catch (e) {
+                        didError = !0, error = e;
+                        continue;
+                    }
+                    break;
                 }
-            }
+            } else didFatal = !0;
         }
-        null !== deadline && (isCallbackScheduled = !1), hasRemainingAsyncWork && !isCallbackScheduled && (scheduleDeferredCallback(performDeferredWork), 
+        priorityContext = previousPriorityContext, null !== deadline && (isCallbackScheduled = !1), 
+        nextPriorityLevel > TaskPriority$1 && !isCallbackScheduled && (scheduleDeferredCallback(performDeferredWork), 
         isCallbackScheduled = !0);
-        var errorToThrow = null !== fatalError ? fatalError : firstUncaughtError;
-        if (isPerformingWork = !1, deadlineHasExpired = !1, fatalError = null, firstUncaughtError = null, 
+        var errorToThrow = firstUncaughtError;
+        if (isPerformingWork = !1, deadlineHasExpired = !1, didFatal = !1, firstUncaughtError = null, 
         capturedErrors = null, failedBoundaries = null, null !== errorToThrow) throw errorToThrow;
     }
     function captureError(failedWork, error) {
-        ReactCurrentOwner$1.current = null, nextUnitOfWork = null;
+        ReactCurrentOwner$1.current = null;
         var boundary = null, errorBoundaryFound = !1, willRetry = !1, errorBoundaryName = null;
-        if (failedWork.tag === HostRoot$4) boundary = failedWork, isFailedBoundary(failedWork) && (fatalError = error); else for (var node = failedWork.return; null !== node && null === boundary; ) {
+        if (failedWork.tag === HostRoot$4) boundary = failedWork, isFailedBoundary(failedWork) && (didFatal = !0); else for (var node = failedWork.return; null !== node && null === boundary; ) {
             if (node.tag === ClassComponent$4) {
                 var instance = node.stateNode;
-                "function" == typeof instance.unstable_handleError && (errorBoundaryFound = !0, 
-                errorBoundaryName = getComponentName_1(node), boundary = node, willRetry = !0);
+                "function" == typeof instance.componentDidCatch && (errorBoundaryFound = !0, errorBoundaryName = getComponentName_1(node), 
+                boundary = node, willRetry = !0);
             } else node.tag === HostRoot$4 && (boundary = node);
             if (isFailedBoundary(node)) {
                 if (isUnmounting) return null;
@@ -3035,7 +2391,8 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         if (null !== boundary) {
             null === failedBoundaries && (failedBoundaries = new Set()), failedBoundaries.add(boundary);
             var _componentStack = getStackAddendumByWorkInProgressFiber(failedWork), _componentName = getComponentName_1(failedWork);
-            return null === capturedErrors && (capturedErrors = new Map()), capturedErrors.set(boundary, {
+            null === capturedErrors && (capturedErrors = new Map());
+            var capturedError = {
                 componentName: _componentName,
                 componentStack: _componentStack,
                 error: error,
@@ -3043,7 +2400,14 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
                 errorBoundaryFound: errorBoundaryFound,
                 errorBoundaryName: errorBoundaryName,
                 willRetry: willRetry
-            }), isCommitting ? (null === commitPhaseBoundaries && (commitPhaseBoundaries = new Set()), 
+            };
+            capturedErrors.set(boundary, capturedError);
+            try {
+                logCapturedError$1(capturedError);
+            } catch (e) {
+                console.error(e);
+            }
+            return isCommitting ? (null === commitPhaseBoundaries && (commitPhaseBoundaries = new Set()), 
             commitPhaseBoundaries.add(boundary)) : scheduleErrorRecovery(boundary), boundary;
         }
         return null === firstUncaughtError && (firstUncaughtError = error), null;
@@ -3056,45 +2420,40 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
     }
     function commitErrorHandling(effectfulFiber) {
         var capturedError = void 0;
-        null !== capturedErrors && (capturedError = capturedErrors.get(effectfulFiber), 
+        switch (null !== capturedErrors && (capturedError = capturedErrors.get(effectfulFiber), 
         capturedErrors.delete(effectfulFiber), null == capturedError && null !== effectfulFiber.alternate && (effectfulFiber = effectfulFiber.alternate, 
         capturedError = capturedErrors.get(effectfulFiber), capturedErrors.delete(effectfulFiber))), 
-        invariant(null != capturedError, "No error for given unit of work. This error is likely caused by a " + "bug in React. Please file an issue.");
-        var error = capturedError.error;
-        try {
-            logCapturedError$1(capturedError);
-        } catch (e) {
-            console.error(e);
-        }
-        switch (effectfulFiber.tag) {
+        invariant(null != capturedError, "No error for given unit of work. This error is likely caused by a " + "bug in React. Please file an issue."), 
+        effectfulFiber.tag) {
           case ClassComponent$4:
             var instance = effectfulFiber.stateNode, info = {
                 componentStack: capturedError.componentStack
             };
-            return void instance.unstable_handleError(error, info);
+            return void instance.componentDidCatch(capturedError.error, info);
 
           case HostRoot$4:
-            return void (null === firstUncaughtError && (firstUncaughtError = error));
+            return void (null === firstUncaughtError && (firstUncaughtError = capturedError.error));
 
           default:
             invariant(!1, "Invalid type of work. This error is likely caused by a bug in " + "React. Please file an issue.");
         }
     }
     function unwindContexts(from, to) {
-        for (var node = from; null !== node && node !== to && node.alternate !== to; ) {
+        for (var node = from; null !== node; ) {
             switch (node.tag) {
               case ClassComponent$4:
                 popContextProvider$1(node);
                 break;
 
-              case HostComponent$4:
+              case HostComponent$3:
                 popHostContext(node);
                 break;
 
               case HostRoot$4:
-              case HostPortal$1:
+              case HostPortal$2:
                 popHostContainer(node);
             }
+            if (node === to || node.alternate === to) break;
             node = node.return;
         }
     }
@@ -3103,7 +2462,11 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         lastScheduledRoot = root) : (nextScheduledRoot = root, lastScheduledRoot = root)));
     }
     function scheduleUpdate(fiber, priorityLevel) {
-        priorityLevel <= nextPriorityLevel && (nextUnitOfWork = null);
+        return scheduleUpdateImpl(fiber, priorityLevel, !1);
+    }
+    function scheduleUpdateImpl(fiber, priorityLevel, isErrorRecovery) {
+        nestedUpdateCount > NESTED_UPDATE_LIMIT && (didFatal = !0, invariant(!1, "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.")), 
+        !isPerformingWork && priorityLevel <= nextPriorityLevel && (nextUnitOfWork = null);
         for (var node = fiber, shouldContinue = !0; null !== node && shouldContinue; ) {
             if (shouldContinue = !1, (node.pendingWorkPriority === NoWork$2 || node.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
             node.pendingWorkPriority = priorityLevel), null !== node.alternate && (node.alternate.pendingWorkPriority === NoWork$2 || node.alternate.pendingWorkPriority > priorityLevel) && (shouldContinue = !0, 
@@ -3131,7 +2494,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         priorityLevel === SynchronousPriority$1 && (isPerformingWork || isBatchingUpdates) ? TaskPriority$1 : priorityLevel;
     }
     function scheduleErrorRecovery(fiber) {
-        scheduleUpdate(fiber, TaskPriority$1);
+        scheduleUpdateImpl(fiber, TaskPriority$1, !0);
     }
     function performWithPriority(priorityLevel, fn) {
         var previousPriorityContext = priorityContext;
@@ -3160,13 +2523,15 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
             isBatchingUpdates = previousIsBatchingUpdates, isUnbatchingUpdates = previousIsUnbatchingUpdates;
         }
     }
-    function syncUpdates(fn) {
-        var previousPriorityContext = priorityContext;
-        priorityContext = SynchronousPriority$1;
+    function flushSync(batch) {
+        var previousIsBatchingUpdates = isBatchingUpdates, previousPriorityContext = priorityContext;
+        isBatchingUpdates = !0, priorityContext = SynchronousPriority$1;
         try {
-            return fn();
+            return batch();
         } finally {
-            priorityContext = previousPriorityContext;
+            isBatchingUpdates = previousIsBatchingUpdates, priorityContext = previousPriorityContext, 
+            invariant(!isPerformingWork, "flushSync was called from inside a lifecycle method. It cannot be " + "called when React is already rendering."), 
+            performWork(TaskPriority$1, null);
         }
     }
     function deferredUpdates(fn) {
@@ -3184,7 +2549,7 @@ var injectInternals_1 = injectInternals$1, onCommitRoot_1 = onCommitRoot$1, onCo
         performWithPriority: performWithPriority,
         batchedUpdates: batchedUpdates,
         unbatchedUpdates: unbatchedUpdates,
-        syncUpdates: syncUpdates,
+        flushSync: flushSync,
         deferredUpdates: deferredUpdates
     };
 }, getContextFiber = function(arg) {
@@ -3201,7 +2566,7 @@ getContextForSubtree._injectFiber = function(fn) {
     getContextFiber = fn;
 };
 
-var getContextForSubtree_1 = getContextForSubtree, addTopLevelUpdate = ReactFiberUpdateQueue.addTopLevelUpdate, findCurrentUnmaskedContext = ReactFiberContext.findCurrentUnmaskedContext, isContextProvider = ReactFiberContext.isContextProvider, processChildContext = ReactFiberContext.processChildContext, createFiberRoot = ReactFiberRoot.createFiberRoot, HostComponent$1 = ReactTypeOfWork.HostComponent, findCurrentHostFiber = ReactFiberTreeReflection.findCurrentHostFiber;
+var getContextForSubtree_1 = getContextForSubtree, addTopLevelUpdate = ReactFiberUpdateQueue.addTopLevelUpdate, findCurrentUnmaskedContext = ReactFiberContext.findCurrentUnmaskedContext, isContextProvider = ReactFiberContext.isContextProvider, processChildContext = ReactFiberContext.processChildContext, createFiberRoot = ReactFiberRoot.createFiberRoot, HostComponent = ReactTypeOfWork.HostComponent, findCurrentHostFiber = ReactFiberTreeReflection.findCurrentHostFiber, findCurrentHostFiberWithNoPortals = ReactFiberTreeReflection.findCurrentHostFiberWithNoPortals;
 
 getContextForSubtree_1._injectFiber(function(fiber) {
     var parentContext = findCurrentUnmaskedContext(fiber);
@@ -3209,9 +2574,9 @@ getContextForSubtree_1._injectFiber(function(fiber) {
 });
 
 var ReactFiberReconciler = function(config) {
-    var getPublicInstance = config.getPublicInstance, _ReactFiberScheduler = ReactFiberScheduler(config), scheduleUpdate = _ReactFiberScheduler.scheduleUpdate, getPriorityContext = _ReactFiberScheduler.getPriorityContext, performWithPriority = _ReactFiberScheduler.performWithPriority, batchedUpdates = _ReactFiberScheduler.batchedUpdates, unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates, syncUpdates = _ReactFiberScheduler.syncUpdates, deferredUpdates = _ReactFiberScheduler.deferredUpdates;
+    var getPublicInstance = config.getPublicInstance, _ReactFiberScheduler = ReactFiberScheduler(config), scheduleUpdate = _ReactFiberScheduler.scheduleUpdate, getPriorityContext = _ReactFiberScheduler.getPriorityContext, performWithPriority = _ReactFiberScheduler.performWithPriority, batchedUpdates = _ReactFiberScheduler.batchedUpdates, unbatchedUpdates = _ReactFiberScheduler.unbatchedUpdates, flushSync = _ReactFiberScheduler.flushSync, deferredUpdates = _ReactFiberScheduler.deferredUpdates;
     function scheduleTopLevelUpdate(current, element, callback) {
-        var forceAsync = ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != element && null != element.type && !0 === element.type.unstable_asyncUpdates, priorityLevel = getPriorityContext(current, forceAsync), nextState = {
+        var forceAsync = ReactFeatureFlags_1.enableAsyncSubtreeAPI && null != element && null != element.type && null != element.type.prototype && !0 === element.type.prototype.unstable_isAsyncReactComponent, priorityLevel = getPriorityContext(current, forceAsync), nextState = {
             element: element
         };
         callback = void 0 === callback ? null : callback, addTopLevelUpdate(current, nextState, callback, priorityLevel), 
@@ -3229,13 +2594,13 @@ var ReactFiberReconciler = function(config) {
         performWithPriority: performWithPriority,
         batchedUpdates: batchedUpdates,
         unbatchedUpdates: unbatchedUpdates,
-        syncUpdates: syncUpdates,
         deferredUpdates: deferredUpdates,
+        flushSync: flushSync,
         getPublicRootInstance: function(container) {
             var containerFiber = container.current;
             if (!containerFiber.child) return null;
             switch (containerFiber.child.tag) {
-              case HostComponent$1:
+              case HostComponent:
                 return getPublicInstance(containerFiber.child.stateNode);
 
               default:
@@ -3245,6 +2610,10 @@ var ReactFiberReconciler = function(config) {
         findHostInstance: function(fiber) {
             var hostFiber = findCurrentHostFiber(fiber);
             return null === hostFiber ? null : hostFiber.stateNode;
+        },
+        findHostInstanceWithNoPortals: function(fiber) {
+            var hostFiber = findCurrentHostFiberWithNoPortals(fiber);
+            return null === hostFiber ? null : hostFiber.stateNode;
         }
     };
 };
@@ -3415,7 +2784,21 @@ var mountSafeCallback = NativeMethodsMixinUtils.mountSafeCallback, ReactNativeFi
         var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, this.viewConfig.validAttributes);
         UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
     }, ReactNativeFiberHostComponent;
-}(), ReactNativeFiberHostComponent_1 = ReactNativeFiberHostComponent, viewConfigs = new Map(), ReactNativeViewConfigRegistry = {
+}(), ReactNativeFiberHostComponent_1 = ReactNativeFiberHostComponent, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
+    tagsStartAt: INITIAL_TAG_COUNT,
+    tagCount: INITIAL_TAG_COUNT,
+    allocateTag: function() {
+        for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
+        var tag = ReactNativeTagHandles.tagCount;
+        return ReactNativeTagHandles.tagCount++, tag;
+    },
+    assertRootTag: function(tag) {
+        invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
+    },
+    reactTagIsNativeTopRootID: function(reactTag) {
+        return reactTag % 10 == 1;
+    }
+}, ReactNativeTagHandles_1 = ReactNativeTagHandles, viewConfigs = new Map(), ReactNativeViewConfigRegistry = {
     register: function(viewConfig) {
         var name = viewConfig.uiViewClassName;
         return invariant(!viewConfigs.has(name), "Tried to register two views with the same name %s", name), 
@@ -3532,7 +2915,7 @@ getInspectorDataForViewTag = function() {
 
 var ReactNativeFiberInspector = {
     getInspectorDataForViewTag: getInspectorDataForViewTag
-}, ReactVersion = "16.0.0-alpha.13", ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
+}, ReactVersion = "16.0.0-beta.5", ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
     return ReactNativeFiberRenderer.findHostInstance(fiber);
 } : function(instance) {
     return instance;
@@ -3549,7 +2932,666 @@ function findNodeHandle(componentOrHandle) {
 var findNodeHandle_1 = findNodeHandle, findNumericNodeHandleFiber = function(componentOrHandle) {
     var instance = findNodeHandle_1(componentOrHandle);
     return null == instance || "number" == typeof instance ? instance : instance._nativeTag;
-}, DevOnlyStubShim = null;
+}, eventPluginOrder = null, namesToPlugins = {};
+
+function recomputePluginOrdering() {
+    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
+        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
+        !EventPluginRegistry.plugins[pluginIndex]) {
+            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
+            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
+            var publishedEvents = pluginModule.eventTypes;
+            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
+        }
+    }
+}
+
+function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
+    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
+    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
+    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+    if (phasedRegistrationNames) {
+        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
+            var phasedRegistrationName = phasedRegistrationNames[phaseName];
+            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+        }
+        return !0;
+    }
+    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
+    !0);
+}
+
+function publishRegistrationName(registrationName, pluginModule, eventName) {
+    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
+    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
+}
+
+var EventPluginRegistry = {
+    plugins: [],
+    eventNameDispatchConfigs: {},
+    registrationNameModules: {},
+    registrationNameDependencies: {},
+    possibleRegistrationNames: null,
+    injectEventPluginOrder: function(injectedEventPluginOrder) {
+        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
+        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
+    },
+    injectEventPluginsByName: function(injectedNamesToPlugins) {
+        var isOrderingDirty = !1;
+        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+            var pluginModule = injectedNamesToPlugins[pluginName];
+            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
+            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
+        }
+        isOrderingDirty && recomputePluginOrdering();
+    }
+}, EventPluginRegistry_1 = EventPluginRegistry;
+
+function accumulateInto(current, next) {
+    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
+    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
+    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+}
+
+var accumulateInto_1 = accumulateInto;
+
+function forEachAccumulated(arr, cb, scope) {
+    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+}
+
+var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
+    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
+}, executeDispatchesAndReleaseSimulated = function(e) {
+    return executeDispatchesAndRelease(e, !0);
+}, executeDispatchesAndReleaseTopLevel = function(e) {
+    return executeDispatchesAndRelease(e, !1);
+};
+
+function isInteractive(tag) {
+    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+    switch (name) {
+      case "onClick":
+      case "onClickCapture":
+      case "onDoubleClick":
+      case "onDoubleClickCapture":
+      case "onMouseDown":
+      case "onMouseDownCapture":
+      case "onMouseMove":
+      case "onMouseMoveCapture":
+      case "onMouseUp":
+      case "onMouseUpCapture":
+        return !(!props.disabled || !isInteractive(type));
+
+      default:
+        return !1;
+    }
+}
+
+var EventPluginHub = {
+    injection: {
+        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
+        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
+    },
+    getListener: function(inst, registrationName) {
+        var listener;
+        if ("number" == typeof inst.tag) {
+            var stateNode = inst.stateNode;
+            if (!stateNode) return null;
+            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
+            if (!props) return null;
+            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
+        } else {
+            var currentElement = inst._currentElement;
+            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
+            if (!inst._rootNodeID) return null;
+            var _props = currentElement.props;
+            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
+        }
+        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
+        listener;
+    },
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
+            var possiblePlugin = plugins[i];
+            if (possiblePlugin) {
+                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+            }
+        }
+        return events;
+    },
+    enqueueEvents: function(events) {
+        events && (eventQueue = accumulateInto_1(eventQueue, events));
+    },
+    processEventQueue: function(simulated) {
+        var processingEventQueue = eventQueue;
+        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
+        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
+        ReactErrorUtils_1.rethrowCaughtError();
+    }
+}, EventPluginHub_1 = EventPluginHub, HostComponent$10 = ReactTypeOfWork.HostComponent;
+
+function getParent(inst) {
+    if (void 0 !== inst._hostParent) return inst._hostParent;
+    if ("number" == typeof inst.tag) {
+        do {
+            inst = inst.return;
+        } while (inst && inst.tag !== HostComponent$10);
+        if (inst) return inst;
+    }
+    return null;
+}
+
+function getLowestCommonAncestor(instA, instB) {
+    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
+    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
+    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
+    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
+    for (var depth = depthA; depth--; ) {
+        if (instA === instB || instA === instB.alternate) return instA;
+        instA = getParent(instA), instB = getParent(instB);
+    }
+    return null;
+}
+
+function isAncestor(instA, instB) {
+    for (;instB; ) {
+        if (instA === instB || instA === instB.alternate) return !0;
+        instB = getParent(instB);
+    }
+    return !1;
+}
+
+function getParentInstance(inst) {
+    return getParent(inst);
+}
+
+function traverseTwoPhase(inst, fn, arg) {
+    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
+    var i;
+    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
+    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
+}
+
+function traverseEnterLeave(from, to, fn, argFrom, argTo) {
+    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
+    from = getParent(from);
+    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
+    var i;
+    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
+    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
+}
+
+var ReactTreeTraversal = {
+    isAncestor: isAncestor,
+    getLowestCommonAncestor: getLowestCommonAncestor,
+    getParentInstance: getParentInstance,
+    traverseTwoPhase: traverseTwoPhase,
+    traverseEnterLeave: traverseEnterLeave
+}, getListener = EventPluginHub_1.getListener;
+
+function listenerAtPhase(inst, event, propagationPhase) {
+    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+    return getListener(inst, registrationName);
+}
+
+function accumulateDirectionalDispatches(inst, phase, event) {
+    var listener = listenerAtPhase(inst, event, phase);
+    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
+}
+
+function accumulateTwoPhaseDispatchesSingle(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+}
+
+function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+    if (event && event.dispatchConfig.phasedRegistrationNames) {
+        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
+        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+    }
+}
+
+function accumulateDispatches(inst, ignoredDirection, event) {
+    if (inst && event && event.dispatchConfig.registrationName) {
+        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+        listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+        event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
+    }
+}
+
+function accumulateDirectDispatchesSingle(event) {
+    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
+}
+
+function accumulateTwoPhaseDispatches(events) {
+    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
+}
+
+function accumulateTwoPhaseDispatchesSkipTarget(events) {
+    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+}
+
+function accumulateEnterLeaveDispatches(leave, enter, from, to) {
+    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
+}
+
+function accumulateDirectDispatches(events) {
+    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
+}
+
+var EventPropagators = {
+    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
+    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
+    accumulateDirectDispatches: accumulateDirectDispatches,
+    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
+}, EventPropagators_1 = EventPropagators, EVENT_POOL_SIZE = 10, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
+    type: null,
+    target: null,
+    currentTarget: emptyFunction.thatReturnsNull,
+    eventPhase: null,
+    bubbles: null,
+    cancelable: null,
+    timeStamp: function(event) {
+        return event.timeStamp || Date.now();
+    },
+    defaultPrevented: null,
+    isTrusted: null
+};
+
+function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
+    var Interface = this.constructor.Interface;
+    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
+        var normalize = Interface[propName];
+        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
+    }
+    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
+    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
+    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
+}
+
+Object.assign(SyntheticEvent.prototype, {
+    preventDefault: function() {
+        this.defaultPrevented = !0;
+        var event = this.nativeEvent;
+        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
+        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
+    },
+    stopPropagation: function() {
+        var event = this.nativeEvent;
+        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
+        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
+    },
+    persist: function() {
+        this.isPersistent = emptyFunction.thatReturnsTrue;
+    },
+    isPersistent: emptyFunction.thatReturnsFalse,
+    destructor: function() {
+        var Interface = this.constructor.Interface;
+        for (var propName in Interface) this[propName] = null;
+        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
+    }
+}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
+    var Super = this, E = function() {};
+    E.prototype = Super.prototype;
+    var prototype = new E();
+    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
+    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
+    addEventPoolingTo(Class);
+}, addEventPoolingTo(SyntheticEvent);
+
+var SyntheticEvent_1 = SyntheticEvent;
+
+function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+    var EventConstructor = this;
+    if (EventConstructor.eventPool.length) {
+        var instance = EventConstructor.eventPool.pop();
+        return EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst), 
+        instance;
+    }
+    return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+}
+
+function releasePooledEvent(event) {
+    var EventConstructor = this;
+    invariant(event instanceof EventConstructor, "Trying to release an event instance  into a pool of a different type."), 
+    event.destructor(), EventConstructor.eventPool.length < EVENT_POOL_SIZE && EventConstructor.eventPool.push(event);
+}
+
+function addEventPoolingTo(EventConstructor) {
+    EventConstructor.eventPool = [], EventConstructor.getPooled = getPooledEvent, EventConstructor.release = releasePooledEvent;
+}
+
+var customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
+
+for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
+
+for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
+allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
+
+var ReactNativeBridgeEventPlugin = {
+    eventTypes: Object.assign({}, customBubblingEventTypes, customDirectEventTypes),
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
+            if (!directDispatchConfig) return null;
+            EventPropagators_1.accumulateDirectDispatches(event);
+        }
+        return event;
+    }
+}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
+
+function runEventQueueInBatch(events) {
+    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
+}
+
+var ReactEventEmitterMixin = {
+    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
+    }
+}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
+    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
+    return ret;
+}, removeTouchesAtIndices = function(touches, indices) {
+    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
+        var index = indices[i];
+        rippedOut.push(touches[index]), temp[index] = null;
+    }
+    for (var fillAt = 0, j = 0; j < temp.length; j++) {
+        var cur = temp[j];
+        null !== cur && (temp[fillAt++] = cur);
+    }
+    return temp.length = fillAt, rippedOut;
+}, ReactNativeEventEmitter = Object.assign({}, ReactEventEmitterMixin_1, {
+    registrationNames: EventPluginRegistry_1.registrationNameModules,
+    getListener: EventPluginHub_1.getListener,
+    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
+        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
+        ReactGenericBatching_1.batchedUpdates(function() {
+            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
+        });
+    },
+    receiveEvent: function(tag, topLevelType, nativeEventParam) {
+        var rootNodeID = tag;
+        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+    },
+    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
+        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
+            var touch = changedTouches[jj];
+            touch.changedTouches = changedTouches, touch.touches = touches;
+            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
+            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt || (rootNodeID = target)), 
+            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+        }
+    }
+}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
+    onChange: function(from, to, blockNativeResponder) {
+        if (null !== to) {
+            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
+            UIManager.setJSResponder(tag, blockNativeResponder);
+        } else UIManager.clearJSResponder();
+    }
+}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
+    touchHistory: function(nativeEvent) {
+        return null;
+    }
+};
+
+function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+}
+
+SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
+
+var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, warning$15, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
+    touchBank: touchBank,
+    numberActiveTouches: 0,
+    indexOfSingleActiveTouch: -1,
+    mostRecentTimeStamp: 0
+};
+
+function timestampForTouch(touch) {
+    return touch.timeStamp || touch.timestamp;
+}
+
+function createTouchRecord(touch) {
+    return {
+        touchActive: !0,
+        startPageX: touch.pageX,
+        startPageY: touch.pageY,
+        startTimeStamp: timestampForTouch(touch),
+        currentPageX: touch.pageX,
+        currentPageY: touch.pageY,
+        currentTimeStamp: timestampForTouch(touch),
+        previousPageX: touch.pageX,
+        previousPageY: touch.pageY,
+        previousTimeStamp: timestampForTouch(touch)
+    };
+}
+
+function resetTouchRecord(touchRecord, touch) {
+    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
+    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
+    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
+    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
+    touchRecord.previousTimeStamp = timestampForTouch(touch);
+}
+
+function getTouchIdentifier(_ref) {
+    var identifier = _ref.identifier;
+    return invariant(null != identifier, "Touch object is missing identifier."), warning$15(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
+    identifier;
+}
+
+function recordTouchStart(touch) {
+    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
+    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+}
+
+function recordTouchMove(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
+    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+}
+
+function recordTouchEnd(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
+    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+}
+
+function printTouch(touch) {
+    return JSON.stringify({
+        identifier: touch.identifier,
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        timestamp: timestampForTouch(touch)
+    });
+}
+
+function printTouchBank() {
+    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
+    printed;
+}
+
+var ResponderTouchHistoryStore = {
+    recordTouchTrack: function(topLevelType, nativeEvent) {
+        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
+        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
+        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) for (var i = 0; i < touchBank.length; i++) {
+            var touchTrackToCheck = touchBank[i];
+            if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
+                touchHistory.indexOfSingleActiveTouch = i;
+                break;
+            }
+        }
+    },
+    touchHistory: touchHistory
+}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
+
+function accumulate(current, next) {
+    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
+    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+}
+
+var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
+    var oldResponderInst = responderInst;
+    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+}, eventTypes = {
+    startShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onStartShouldSetResponder",
+            captured: "onStartShouldSetResponderCapture"
+        }
+    },
+    scrollShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onScrollShouldSetResponder",
+            captured: "onScrollShouldSetResponderCapture"
+        }
+    },
+    selectionChangeShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onSelectionChangeShouldSetResponder",
+            captured: "onSelectionChangeShouldSetResponderCapture"
+        }
+    },
+    moveShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onMoveShouldSetResponder",
+            captured: "onMoveShouldSetResponderCapture"
+        }
+    },
+    responderStart: {
+        registrationName: "onResponderStart"
+    },
+    responderMove: {
+        registrationName: "onResponderMove"
+    },
+    responderEnd: {
+        registrationName: "onResponderEnd"
+    },
+    responderRelease: {
+        registrationName: "onResponderRelease"
+    },
+    responderTerminationRequest: {
+        registrationName: "onResponderTerminationRequest"
+    },
+    responderGrant: {
+        registrationName: "onResponderGrant"
+    },
+    responderReject: {
+        registrationName: "onResponderReject"
+    },
+    responderTerminate: {
+        registrationName: "onResponderTerminate"
+    }
+};
+
+function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
+    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
+    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
+    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
+    !wantsResponderInst || wantsResponderInst === responderInst) return null;
+    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
+    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
+    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
+    if (responderInst) {
+        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
+        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
+        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
+        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
+        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
+        shouldSwitch) {
+            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
+            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
+        } else {
+            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
+            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
+            extracted = accumulate_1(extracted, rejectEvent);
+        }
+    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
+    return extracted;
+}
+
+function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
+    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
+}
+
+function noResponderTouches(nativeEvent) {
+    var touches = nativeEvent.touches;
+    if (!touches || 0 === touches.length) return !0;
+    for (var i = 0; i < touches.length; i++) {
+        var activeTouch = touches[i], target = activeTouch.target;
+        if (null !== target && void 0 !== target && 0 !== target) {
+            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
+            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
+        }
+    }
+    return !0;
+}
+
+var ResponderEventPlugin = {
+    _getResponder: function() {
+        return responderInst;
+    },
+    eventTypes: eventTypes,
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
+            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
+            null;
+            trackedTouchCount -= 1;
+        }
+        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
+        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
+        if (incrementalTouch) {
+            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
+            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
+            extracted = accumulate_1(extracted, gesture);
+        }
+        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
+        if (finalTouch) {
+            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
+            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
+            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
+        }
+        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
+        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
+        previousActiveTouches = numberActiveTouches, extracted;
+    },
+    GlobalResponderHandler: null,
+    GlobalInteractionHandler: null,
+    injection: {
+        injectGlobalResponderHandler: function(GlobalResponderHandler) {
+            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+        },
+        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
+            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+        }
+    }
+}, ResponderEventPlugin_1 = ResponderEventPlugin;
+
+RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
+EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
+EventPluginHub_1.injection.injectEventPluginsByName({
+    ResponderEventPlugin: ResponderEventPlugin_1,
+    ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
+});
+
+var DevOnlyStubShim = null;
 
 function _classCallCheck$2(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
@@ -3713,7 +3755,7 @@ function takeSnapshot(view, options) {
 
 var takeSnapshot_1 = takeSnapshot, injectInternals = ReactFiberDevToolsHook.injectInternals;
 
-ReactNativeInjection.inject(), ReactGenericBatching_1.injection.injectFiberBatchedUpdates(ReactNativeFiberRenderer.batchedUpdates);
+ReactGenericBatching_1.injection.injectFiberBatchedUpdates(ReactNativeFiberRenderer.batchedUpdates);
 
 var roots = new Map();
 
@@ -3741,6 +3783,7 @@ var ReactNativeFiber = {
         return ReactPortal.createPortal(children, containerTag, null, key);
     },
     unstable_batchedUpdates: ReactGenericBatching_1.batchedUpdates,
+    flushSync: ReactNativeFiberRenderer.flushSync,
     __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
         NativeMethodsMixin: NativeMethodsMixin_1,
         ReactGlobalSharedState: ReactGlobalSharedState_1,
@@ -3752,7 +3795,7 @@ var ReactNativeFiber = {
     }
 };
 
-"function" == typeof injectInternals && injectInternals({
+injectInternals({
     findFiberByHostInstance: ReactNativeComponentTree_1.getClosestInstanceFromNode,
     findHostInstanceByFiber: ReactNativeFiberRenderer.findHostInstance,
     getInspectorDataForViewTag: ReactNativeFiberInspector.getInspectorDataForViewTag,
diff --git a/Libraries/Renderer/ReactNativeStack-dev.js b/Libraries/Renderer/ReactNativeStack-dev.js
index 0d3dca10c72..65aac731afe 100644
--- a/Libraries/Renderer/ReactNativeStack-dev.js
+++ b/Libraries/Renderer/ReactNativeStack-dev.js
@@ -11,2227 +11,2148 @@
  */
 "use strict";
 
-var invariant = require("fbjs/lib/invariant");
-
-require("InitializeCore");
-
-var warning = require("fbjs/lib/warning"), RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), UIManager = require("UIManager"), React = require("react"), ExecutionEnvironment = require("fbjs/lib/ExecutionEnvironment"), performanceNow = require("fbjs/lib/performanceNow"), emptyObject = require("fbjs/lib/emptyObject"), checkPropTypes = require("prop-types/checkPropTypes"), shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState"), deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev"), instanceCache = {}, instanceProps = {};
-
-function getRenderedHostOrTextFromComponent(component) {
-    for (var rendered; rendered = component._renderedComponent; ) component = rendered;
-    return component;
-}
-
-function precacheNode(inst, tag) {
-    var nativeInst = getRenderedHostOrTextFromComponent(inst);
-    instanceCache[tag] = nativeInst;
-}
-
-function precacheFiberNode(hostInst, tag) {
-    instanceCache[tag] = hostInst;
-}
-
-function uncacheNode(inst) {
-    var tag = inst._rootNodeID;
-    tag && delete instanceCache[tag];
-}
-
-function uncacheFiberNode(tag) {
-    delete instanceCache[tag], delete instanceProps[tag];
-}
-
-function getInstanceFromTag(tag) {
-    return instanceCache[tag] || null;
-}
-
-function getTagFromInstance(inst) {
-    var tag = "number" != typeof inst.tag ? inst._rootNodeID : inst.stateNode._nativeTag;
-    return invariant(tag, "All native instances should have a tag."), tag;
-}
-
-function getFiberCurrentPropsFromNode(stateNode) {
-    return instanceProps[stateNode._nativeTag] || null;
-}
-
-function updateFiberProps(tag, props) {
-    instanceProps[tag] = props;
-}
-
-var ReactNativeComponentTree = {
-    getClosestInstanceFromNode: getInstanceFromTag,
-    getInstanceFromNode: getInstanceFromTag,
-    getNodeFromInstance: getTagFromInstance,
-    precacheFiberNode: precacheFiberNode,
-    precacheNode: precacheNode,
-    uncacheFiberNode: uncacheFiberNode,
-    uncacheNode: uncacheNode,
-    getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
-    updateFiberProps: updateFiberProps
-}, ReactNativeComponentTree_1 = ReactNativeComponentTree, eventPluginOrder = null, namesToPlugins = {};
-
-function recomputePluginOrdering() {
-    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
-        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
-        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
-        !EventPluginRegistry.plugins[pluginIndex]) {
-            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
-            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
-            var publishedEvents = pluginModule.eventTypes;
-            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
-        }
+__DEV__ && function() {
+    var invariant = require("fbjs/lib/invariant"), React = require("react"), warning = require("fbjs/lib/warning"), ExecutionEnvironment = require("fbjs/lib/ExecutionEnvironment"), performanceNow = require("fbjs/lib/performanceNow"), emptyObject = require("fbjs/lib/emptyObject"), UIManager = require("UIManager"), checkPropTypes = require("prop-types/checkPropTypes"), shallowEqual = require("fbjs/lib/shallowEqual");
+    require("InitializeCore");
+    var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState"), deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev"), instanceCache = {}, instanceProps = {};
+    function getRenderedHostOrTextFromComponent(component) {
+        for (var rendered; rendered = component._renderedComponent; ) component = rendered;
+        return component;
     }
-}
-
-function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
-    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
-    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-    if (phasedRegistrationNames) {
-        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
-            var phasedRegistrationName = phasedRegistrationNames[phaseName];
-            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
-        }
-        return !0;
+    function precacheNode(inst, tag) {
+        var nativeInst = getRenderedHostOrTextFromComponent(inst);
+        instanceCache[tag] = nativeInst;
     }
-    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
-    !0);
-}
-
-function publishRegistrationName(registrationName, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
-    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
-    var lowerCasedName = registrationName.toLowerCase();
-    EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName, 
-    "onDoubleClick" === registrationName && (EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName);
-}
-
-var EventPluginRegistry = {
-    plugins: [],
-    eventNameDispatchConfigs: {},
-    registrationNameModules: {},
-    registrationNameDependencies: {},
-    possibleRegistrationNames: {},
-    injectEventPluginOrder: function(injectedEventPluginOrder) {
-        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
-        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
-    },
-    injectEventPluginsByName: function(injectedNamesToPlugins) {
-        var isOrderingDirty = !1;
-        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
-            var pluginModule = injectedNamesToPlugins[pluginName];
-            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
-            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
-        }
-        isOrderingDirty && recomputePluginOrdering();
+    function precacheFiberNode(hostInst, tag) {
+        instanceCache[tag] = hostInst;
     }
-}, EventPluginRegistry_1 = EventPluginRegistry, caughtError = null, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-    var funcArgs = Array.prototype.slice.call(arguments, 3);
-    try {
-        func.apply(context, funcArgs);
-    } catch (error) {
-        return error;
+    function uncacheNode(inst) {
+        var tag = inst._rootNodeID;
+        tag && delete instanceCache[tag];
     }
-    return null;
-};
-
-if ("undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) {
-    var fakeNode = document.createElement("react"), depth = 0;
-    invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-        depth++;
-        var thisDepth = depth, funcArgs = Array.prototype.slice.call(arguments, 3), boundFunc = function() {
-            func.apply(context, funcArgs);
-        }, fakeEventError = null, onFakeEventError = function(event) {
-            depth === thisDepth && (fakeEventError = event.error);
-        }, evtType = "react-" + (name || "invokeguardedcallback") + "-" + depth;
-        window.addEventListener("error", onFakeEventError), fakeNode.addEventListener(evtType, boundFunc, !1);
-        var evt = document.createEvent("Event");
-        return evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), fakeNode.removeEventListener(evtType, boundFunc, !1), 
-        window.removeEventListener("error", onFakeEventError), depth--, fakeEventError;
+    function uncacheFiberNode(tag) {
+        delete instanceCache[tag], delete instanceProps[tag];
+    }
+    function getInstanceFromTag(tag) {
+        return instanceCache[tag] || null;
+    }
+    function getTagFromInstance(inst) {
+        var tag = "number" != typeof inst.tag ? inst._rootNodeID : inst.stateNode._nativeTag;
+        return invariant(tag, "All native instances should have a tag."), tag;
+    }
+    function getFiberCurrentPropsFromNode(stateNode) {
+        return instanceProps[stateNode._nativeTag] || null;
+    }
+    function updateFiberProps(tag, props) {
+        instanceProps[tag] = props;
+    }
+    var ReactNativeComponentTree = {
+        getClosestInstanceFromNode: getInstanceFromTag,
+        getInstanceFromNode: getInstanceFromTag,
+        getNodeFromInstance: getTagFromInstance,
+        precacheFiberNode: precacheFiberNode,
+        precacheNode: precacheNode,
+        uncacheFiberNode: uncacheFiberNode,
+        uncacheNode: uncacheNode,
+        getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
+        updateFiberProps: updateFiberProps
+    }, ReactNativeComponentTree_1 = ReactNativeComponentTree, ReactInvalidSetStateWarningHook = {}, warning$2 = warning, processingChildContext = !1, warnInvalidSetState = function() {
+        warning$2(!processingChildContext, "setState(...): Cannot call setState() inside getChildContext()");
     };
-}
-
-var rethrowCaughtError = function() {
-    if (caughtError) {
-        var error = caughtError;
-        throw caughtError = null, error;
-    }
-}, ReactErrorUtils = {
-    injection: {
-        injectErrorUtils: function(injectedErrorUtils) {
-            invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
-            invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
+    ReactInvalidSetStateWarningHook = {
+        onBeginProcessingChildContext: function() {
+            processingChildContext = !0;
+        },
+        onEndProcessingChildContext: function() {
+            processingChildContext = !1;
+        },
+        onSetState: function() {
+            warnInvalidSetState();
         }
-    },
-    invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
-        return invokeGuardedCallback.apply(this, arguments);
-    },
-    invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
-        var error = ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
-        null !== error && null === caughtError && (caughtError = error);
-    },
-    rethrowCaughtError: function() {
-        return rethrowCaughtError.apply(this, arguments);
-    }
-}, ReactErrorUtils_1 = ReactErrorUtils, ComponentTree, injection = {
-    injectComponentTree: function(Injected) {
-        ComponentTree = Injected, warning(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, "EventPluginUtils.injection.injectComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.");
-    }
-};
-
-function isEndish(topLevelType) {
-    return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
-}
-
-function isMoveish(topLevelType) {
-    return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
-}
-
-function isStartish(topLevelType) {
-    return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
-}
-
-var validateEventDispatches;
-
-validateEventDispatches = function(event) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances, listenersIsArr = Array.isArray(dispatchListeners), listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0, instancesIsArr = Array.isArray(dispatchInstances), instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
-    warning(instancesIsArr === listenersIsArr && instancesLen === listenersLen, "EventPluginUtils: Invalid `event`.");
-};
-
-function executeDispatch(event, simulated, listener, inst) {
-    var type = event.type || "unknown-event";
-    event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
-    event.currentTarget = null;
-}
-
-function executeDispatchesInOrder(event, simulated) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (validateEventDispatches(event), Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
-    event._dispatchListeners = null, event._dispatchInstances = null;
-}
-
-function executeDispatchesInOrderStopAtTrueImpl(event) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (validateEventDispatches(event), Array.isArray(dispatchListeners)) {
-        for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
-    } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
-    return null;
-}
-
-function executeDispatchesInOrderStopAtTrue(event) {
-    var ret = executeDispatchesInOrderStopAtTrueImpl(event);
-    return event._dispatchInstances = null, event._dispatchListeners = null, ret;
-}
-
-function executeDirectDispatch(event) {
-    validateEventDispatches(event);
-    var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
-    invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
-    event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
-    var res = dispatchListener ? dispatchListener(event) : null;
-    return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
-    res;
-}
-
-function hasDispatches(event) {
-    return !!event._dispatchListeners;
-}
-
-var EventPluginUtils = {
-    isEndish: isEndish,
-    isMoveish: isMoveish,
-    isStartish: isStartish,
-    executeDirectDispatch: executeDirectDispatch,
-    executeDispatchesInOrder: executeDispatchesInOrder,
-    executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
-    hasDispatches: hasDispatches,
-    getFiberCurrentPropsFromNode: function(node) {
-        return ComponentTree.getFiberCurrentPropsFromNode(node);
-    },
-    getInstanceFromNode: function(node) {
-        return ComponentTree.getInstanceFromNode(node);
-    },
-    getNodeFromInstance: function(node) {
-        return ComponentTree.getNodeFromInstance(node);
-    },
-    injection: injection
-}, EventPluginUtils_1 = EventPluginUtils;
-
-function accumulateInto(current, next) {
-    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
-    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulateInto_1 = accumulateInto;
-
-function forEachAccumulated(arr, cb, scope) {
-    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
-}
-
-var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
-    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
-}, executeDispatchesAndReleaseSimulated = function(e) {
-    return executeDispatchesAndRelease(e, !0);
-}, executeDispatchesAndReleaseTopLevel = function(e) {
-    return executeDispatchesAndRelease(e, !1);
-};
-
-function isInteractive(tag) {
-    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-    switch (name) {
-      case "onClick":
-      case "onClickCapture":
-      case "onDoubleClick":
-      case "onDoubleClickCapture":
-      case "onMouseDown":
-      case "onMouseDownCapture":
-      case "onMouseMove":
-      case "onMouseMoveCapture":
-      case "onMouseUp":
-      case "onMouseUpCapture":
-        return !(!props.disabled || !isInteractive(type));
-
-      default:
-        return !1;
-    }
-}
-
-var EventPluginHub = {
-    injection: {
-        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
-        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
-    },
-    getListener: function(inst, registrationName) {
-        var listener;
-        if ("number" == typeof inst.tag) {
-            var stateNode = inst.stateNode;
-            if (!stateNode) return null;
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
-            if (!props) return null;
-            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
-        } else {
-            var currentElement = inst._currentElement;
-            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
-            if (!inst._rootNodeID) return null;
-            var _props = currentElement.props;
-            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
+    };
+    var ReactInvalidSetStateWarningHook_1 = ReactInvalidSetStateWarningHook, ReactHostOperationHistoryHook = null, history = [];
+    ReactHostOperationHistoryHook = {
+        onHostOperation: function(operation) {
+            history.push(operation);
+        },
+        clearHistory: function() {
+            ReactHostOperationHistoryHook._preventClearing || (history = []);
+        },
+        getHistory: function() {
+            return history;
         }
-        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
-        listener;
-    },
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
-            var possiblePlugin = plugins[i];
-            if (possiblePlugin) {
-                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+    };
+    var ReactHostOperationHistoryHook_1 = ReactHostOperationHistoryHook, ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, ReactGlobalSharedState = {
+        ReactCurrentOwner: ReactInternals.ReactCurrentOwner
+    };
+    Object.assign(ReactGlobalSharedState, {
+        ReactComponentTreeHook: ReactInternals.ReactComponentTreeHook,
+        ReactDebugCurrentFrame: ReactInternals.ReactDebugCurrentFrame
+    });
+    var ReactGlobalSharedState_1 = ReactGlobalSharedState, ReactComponentTreeHook = ReactGlobalSharedState_1.ReactComponentTreeHook, warning$1 = warning, ReactDebugTool$1 = null, hooks = [], didHookThrowForEvent = {}, callHook = function(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
+        try {
+            fn.call(context, arg1, arg2, arg3, arg4, arg5);
+        } catch (e) {
+            warning$1(didHookThrowForEvent[event], "Exception thrown by hook while handling %s: %s", event, e + "\n" + e.stack), 
+            didHookThrowForEvent[event] = !0;
+        }
+    }, emitEvent = function(event, arg1, arg2, arg3, arg4, arg5) {
+        for (var i = 0; i < hooks.length; i++) {
+            var hook = hooks[i], fn = hook[event];
+            fn && callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
+        }
+    }, isProfiling = !1, flushHistory = [], lifeCycleTimerStack = [], currentFlushNesting = 0, currentFlushMeasurements = [], currentFlushStartTime = 0, currentTimerDebugID = null, currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerType = null, lifeCycleTimerHasWarned = !1, clearHistory = function() {
+        ReactComponentTreeHook.purgeUnmountedComponents(), ReactHostOperationHistoryHook_1.clearHistory();
+    }, getTreeSnapshot = function(registeredIDs) {
+        return registeredIDs.reduce(function(tree, id) {
+            var ownerID = ReactComponentTreeHook.getOwnerID(id), parentID = ReactComponentTreeHook.getParentID(id);
+            return tree[id] = {
+                displayName: ReactComponentTreeHook.getDisplayName(id),
+                text: ReactComponentTreeHook.getText(id),
+                updateCount: ReactComponentTreeHook.getUpdateCount(id),
+                childIDs: ReactComponentTreeHook.getChildIDs(id),
+                ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
+                parentID: parentID
+            }, tree;
+        }, {});
+    }, resetMeasurements = function() {
+        var previousStartTime = currentFlushStartTime, previousMeasurements = currentFlushMeasurements, previousOperations = ReactHostOperationHistoryHook_1.getHistory();
+        if (0 === currentFlushNesting) return currentFlushStartTime = 0, currentFlushMeasurements = [], 
+        void clearHistory();
+        if (previousMeasurements.length || previousOperations.length) {
+            var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
+            flushHistory.push({
+                duration: performanceNow() - previousStartTime,
+                measurements: previousMeasurements || [],
+                operations: previousOperations || [],
+                treeSnapshot: getTreeSnapshot(registeredIDs)
+            });
+        }
+        clearHistory(), currentFlushStartTime = performanceNow(), currentFlushMeasurements = [];
+    }, checkDebugID = function(debugID) {
+        arguments.length > 1 && void 0 !== arguments[1] && arguments[1] && 0 === debugID || debugID || warning$1(!1, "ReactDebugTool: debugID may not be empty.");
+    }, beginLifeCycleTimer = function(debugID, timerType) {
+        0 !== currentFlushNesting && (currentTimerType && !lifeCycleTimerHasWarned && (warning$1(!1, "There is an internal error in the React performance measurement code." + "\n\nDid not expect %s timer to start while %s timer is still in " + "progress for %s instance.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
+        lifeCycleTimerHasWarned = !0), currentTimerStartTime = performanceNow(), currentTimerNestedFlushDuration = 0, 
+        currentTimerDebugID = debugID, currentTimerType = timerType);
+    }, endLifeCycleTimer = function(debugID, timerType) {
+        0 !== currentFlushNesting && (currentTimerType === timerType || lifeCycleTimerHasWarned || (warning$1(!1, "There is an internal error in the React performance measurement code. " + "We did not expect %s timer to stop while %s timer is still in " + "progress for %s instance. Please report this as a bug in React.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
+        lifeCycleTimerHasWarned = !0), isProfiling && currentFlushMeasurements.push({
+            timerType: timerType,
+            instanceID: debugID,
+            duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
+        }), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerDebugID = null, 
+        currentTimerType = null);
+    }, pauseCurrentLifeCycleTimer = function() {
+        var currentTimer = {
+            startTime: currentTimerStartTime,
+            nestedFlushStartTime: performanceNow(),
+            debugID: currentTimerDebugID,
+            timerType: currentTimerType
+        };
+        lifeCycleTimerStack.push(currentTimer), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, 
+        currentTimerDebugID = null, currentTimerType = null;
+    }, resumeCurrentLifeCycleTimer = function() {
+        var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(), startTime = _lifeCycleTimerStack$.startTime, nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime, debugID = _lifeCycleTimerStack$.debugID, timerType = _lifeCycleTimerStack$.timerType, nestedFlushDuration = performanceNow() - nestedFlushStartTime;
+        currentTimerStartTime = startTime, currentTimerNestedFlushDuration += nestedFlushDuration, 
+        currentTimerDebugID = debugID, currentTimerType = timerType;
+    }, lastMarkTimeStamp = 0, canUsePerformanceMeasure = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, shouldMark = function(debugID) {
+        if (!isProfiling || !canUsePerformanceMeasure) return !1;
+        var element = ReactComponentTreeHook.getElement(debugID);
+        return null != element && "object" == typeof element && !("string" == typeof element.type);
+    }, markBegin = function(debugID, markType) {
+        if (shouldMark(debugID)) {
+            var markName = debugID + "::" + markType;
+            lastMarkTimeStamp = performanceNow(), performance.mark(markName);
+        }
+    }, markEnd = function(debugID, markType) {
+        if (shouldMark(debugID)) {
+            var markName = debugID + "::" + markType, displayName = ReactComponentTreeHook.getDisplayName(debugID) || "Unknown";
+            if (performanceNow() - lastMarkTimeStamp > .1) {
+                var measurementName = displayName + " [" + markType + "]";
+                performance.measure(measurementName, markName);
+            }
+            performance.clearMarks(markName), measurementName && performance.clearMeasures(measurementName);
+        }
+    };
+    ReactDebugTool$1 = {
+        addHook: function(hook) {
+            hooks.push(hook);
+        },
+        removeHook: function(hook) {
+            for (var i = 0; i < hooks.length; i++) hooks[i] === hook && (hooks.splice(i, 1), 
+            i--);
+        },
+        isProfiling: function() {
+            return isProfiling;
+        },
+        beginProfiling: function() {
+            isProfiling || (isProfiling = !0, flushHistory.length = 0, resetMeasurements(), 
+            ReactDebugTool$1.addHook(ReactHostOperationHistoryHook_1));
+        },
+        endProfiling: function() {
+            isProfiling && (isProfiling = !1, resetMeasurements(), ReactDebugTool$1.removeHook(ReactHostOperationHistoryHook_1));
+        },
+        getFlushHistory: function() {
+            return flushHistory;
+        },
+        onBeginFlush: function() {
+            currentFlushNesting++, resetMeasurements(), pauseCurrentLifeCycleTimer(), emitEvent("onBeginFlush");
+        },
+        onEndFlush: function() {
+            resetMeasurements(), currentFlushNesting--, resumeCurrentLifeCycleTimer(), emitEvent("onEndFlush");
+        },
+        onBeginLifeCycleTimer: function(debugID, timerType) {
+            checkDebugID(debugID), emitEvent("onBeginLifeCycleTimer", debugID, timerType), markBegin(debugID, timerType), 
+            beginLifeCycleTimer(debugID, timerType);
+        },
+        onEndLifeCycleTimer: function(debugID, timerType) {
+            checkDebugID(debugID), endLifeCycleTimer(debugID, timerType), markEnd(debugID, timerType), 
+            emitEvent("onEndLifeCycleTimer", debugID, timerType);
+        },
+        onBeginProcessingChildContext: function() {
+            emitEvent("onBeginProcessingChildContext");
+        },
+        onEndProcessingChildContext: function() {
+            emitEvent("onEndProcessingChildContext");
+        },
+        onHostOperation: function(operation) {
+            checkDebugID(operation.instanceID), emitEvent("onHostOperation", operation);
+        },
+        onSetState: function() {
+            emitEvent("onSetState");
+        },
+        onSetChildren: function(debugID, childDebugIDs) {
+            checkDebugID(debugID), childDebugIDs.forEach(checkDebugID), emitEvent("onSetChildren", debugID, childDebugIDs);
+        },
+        onBeforeMountComponent: function(debugID, element, parentDebugID) {
+            checkDebugID(debugID), checkDebugID(parentDebugID, !0), emitEvent("onBeforeMountComponent", debugID, element, parentDebugID), 
+            markBegin(debugID, "mount");
+        },
+        onMountComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "mount"), emitEvent("onMountComponent", debugID);
+        },
+        onBeforeUpdateComponent: function(debugID, element) {
+            checkDebugID(debugID), emitEvent("onBeforeUpdateComponent", debugID, element), markBegin(debugID, "update");
+        },
+        onUpdateComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "update"), emitEvent("onUpdateComponent", debugID);
+        },
+        onBeforeUnmountComponent: function(debugID) {
+            checkDebugID(debugID), emitEvent("onBeforeUnmountComponent", debugID), markBegin(debugID, "unmount");
+        },
+        onUnmountComponent: function(debugID) {
+            checkDebugID(debugID), markEnd(debugID, "unmount"), emitEvent("onUnmountComponent", debugID);
+        },
+        onTestEvent: function() {
+            emitEvent("onTestEvent");
+        }
+    }, ReactDebugTool$1.addHook(ReactInvalidSetStateWarningHook_1), ReactDebugTool$1.addHook(ReactComponentTreeHook), 
+    /[?&]react_perf\b/.test(ExecutionEnvironment.canUseDOM && window.location.href || "") && ReactDebugTool$1.beginProfiling();
+    var ReactDebugTool_1 = ReactDebugTool$1, debugTool = null;
+    debugTool = ReactDebugTool_1;
+    var ReactInstrumentation = {
+        debugTool: debugTool
+    };
+    function ReactNativeContainerInfo(tag) {
+        return {
+            _tag: tag
+        };
+    }
+    var ReactNativeContainerInfo_1 = ReactNativeContainerInfo, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
+        tagsStartAt: INITIAL_TAG_COUNT,
+        tagCount: INITIAL_TAG_COUNT,
+        allocateTag: function() {
+            for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
+            var tag = ReactNativeTagHandles.tagCount;
+            return ReactNativeTagHandles.tagCount++, tag;
+        },
+        assertRootTag: function(tag) {
+            invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
+        },
+        reactTagIsNativeTopRootID: function(reactTag) {
+            return reactTag % 10 == 1;
+        }
+    }, ReactNativeTagHandles_1 = ReactNativeTagHandles, ReactTypeOfWork = {
+        IndeterminateComponent: 0,
+        FunctionalComponent: 1,
+        ClassComponent: 2,
+        HostRoot: 3,
+        HostPortal: 4,
+        HostComponent: 5,
+        HostText: 6,
+        CoroutineComponent: 7,
+        CoroutineHandlerPhase: 8,
+        YieldComponent: 9,
+        Fragment: 10
+    }, ClassComponent = ReactTypeOfWork.ClassComponent;
+    function isValidOwner(object) {
+        return !(!object || "function" != typeof object.attachRef || "function" != typeof object.detachRef);
+    }
+    var ReactOwner = {
+        addComponentAsRefTo: function(component, ref, owner) {
+            if (owner && owner.tag === ClassComponent) {
+                var inst = owner.stateNode;
+                (inst.refs === emptyObject ? inst.refs = {} : inst.refs)[ref] = component.getPublicInstance();
+            } else invariant(isValidOwner(owner), "addComponentAsRefTo(...): Only a ReactOwner can have refs. You might " + "be adding a ref to a component that was not created inside a component's " + "`render` method, or you have multiple copies of React loaded " + "(details: https://fb.me/react-refs-must-have-owner)."), 
+            owner.attachRef(ref, component);
+        },
+        removeComponentAsRefFrom: function(component, ref, owner) {
+            if (owner && owner.tag === ClassComponent) {
+                var inst = owner.stateNode;
+                inst && inst.refs[ref] === component.getPublicInstance() && delete inst.refs[ref];
+            } else {
+                invariant(isValidOwner(owner), "removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might " + "be removing a ref to a component that was not created inside a component's " + "`render` method, or you have multiple copies of React loaded " + "(details: https://fb.me/react-refs-must-have-owner).");
+                var ownerPublicInstance = owner.getPublicInstance();
+                ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance() && owner.detachRef(ref);
             }
         }
-        return events;
-    },
-    enqueueEvents: function(events) {
-        events && (eventQueue = accumulateInto_1(eventQueue, events));
-    },
-    processEventQueue: function(simulated) {
-        var processingEventQueue = eventQueue;
-        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
-        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
-        ReactErrorUtils_1.rethrowCaughtError();
+    }, ReactOwner_1 = ReactOwner, ReactCompositeComponentTypes$1 = {
+        ImpureClass: 0,
+        PureClass: 1,
+        StatelessFunctional: 2
+    }, ReactRef = {}, ReactCompositeComponentTypes = ReactCompositeComponentTypes$1, _require = ReactGlobalSharedState_1, ReactComponentTreeHook$1 = _require.ReactComponentTreeHook, warning$4 = warning, warnedAboutStatelessRefs = {};
+    function attachRef(ref, component, owner) {
+        if (component._compositeType === ReactCompositeComponentTypes.StatelessFunctional) {
+            var info = "", ownerName = void 0;
+            owner && ("function" == typeof owner.getName && (ownerName = owner.getName()), ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`."));
+            var warningKey = ownerName || component._debugID, element = component._currentElement;
+            element && element._source && (warningKey = element._source.fileName + ":" + element._source.lineNumber), 
+            warnedAboutStatelessRefs[warningKey] || (warnedAboutStatelessRefs[warningKey] = !0, 
+            warning$4(!1, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactComponentTreeHook$1.getStackAddendumByID(component._debugID)));
+        }
+        "function" == typeof ref ? ref(component.getPublicInstance()) : ReactOwner_1.addComponentAsRefTo(component, ref, owner);
     }
-}, EventPluginHub_1 = EventPluginHub, ReactTypeOfWork = {
-    IndeterminateComponent: 0,
-    FunctionalComponent: 1,
-    ClassComponent: 2,
-    HostRoot: 3,
-    HostPortal: 4,
-    HostComponent: 5,
-    HostText: 6,
-    CoroutineComponent: 7,
-    CoroutineHandlerPhase: 8,
-    YieldComponent: 9,
-    Fragment: 10
-}, HostComponent = ReactTypeOfWork.HostComponent;
-
-function getParent(inst) {
-    if (void 0 !== inst._hostParent) return inst._hostParent;
-    if ("number" == typeof inst.tag) {
-        do {
-            inst = inst.return;
-        } while (inst && inst.tag !== HostComponent);
-        if (inst) return inst;
+    function detachRef(ref, component, owner) {
+        "function" == typeof ref ? ref(null) : ReactOwner_1.removeComponentAsRefFrom(component, ref, owner);
     }
-    return null;
-}
-
-function getLowestCommonAncestor(instA, instB) {
-    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
-    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
-    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
-    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
-    for (var depth = depthA; depth--; ) {
-        if (instA === instB || instA === instB.alternate) return instA;
-        instA = getParent(instA), instB = getParent(instB);
+    ReactRef.attachRefs = function(instance, element) {
+        if (null !== element && "object" == typeof element) {
+            var ref = element.ref;
+            null != ref && attachRef(ref, instance, element._owner);
+        }
+    }, ReactRef.shouldUpdateRefs = function(prevElement, nextElement) {
+        var prevRef = null, prevOwner = null;
+        null !== prevElement && "object" == typeof prevElement && (prevRef = prevElement.ref, 
+        prevOwner = prevElement._owner);
+        var nextRef = null, nextOwner = null;
+        return null !== nextElement && "object" == typeof nextElement && (nextRef = nextElement.ref, 
+        nextOwner = nextElement._owner), prevRef !== nextRef || "string" == typeof nextRef && nextOwner !== prevOwner;
+    }, ReactRef.detachRefs = function(instance, element) {
+        if (null !== element && "object" == typeof element) {
+            var ref = element.ref;
+            null != ref && detachRef(ref, instance, element._owner);
+        }
+    };
+    var ReactRef_1 = ReactRef;
+    function attachRefs() {
+        ReactRef_1.attachRefs(this, this._currentElement);
     }
-    return null;
-}
-
-function isAncestor(instA, instB) {
-    for (;instB; ) {
-        if (instA === instB || instA === instB.alternate) return !0;
-        instB = getParent(instB);
+    var ReactReconciler = {
+        mountComponent: function(internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID) {
+            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
+            var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
+            return internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), 
+            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID), 
+            markup;
+        },
+        getHostNode: function(internalInstance) {
+            return internalInstance.getHostNode();
+        },
+        unmountComponent: function(internalInstance, safely, skipLifecycle) {
+            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID), 
+            ReactRef_1.detachRefs(internalInstance, internalInstance._currentElement), internalInstance.unmountComponent(safely, skipLifecycle), 
+            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
+        },
+        receiveComponent: function(internalInstance, nextElement, transaction, context) {
+            var prevElement = internalInstance._currentElement;
+            if (nextElement !== prevElement || context !== internalInstance._context) {
+                0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
+                var refsChanged = ReactRef_1.shouldUpdateRefs(prevElement, nextElement);
+                refsChanged && ReactRef_1.detachRefs(internalInstance, prevElement), internalInstance.receiveComponent(nextElement, transaction, context), 
+                refsChanged && internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), 
+                0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
+            }
+        },
+        performUpdateIfNecessary: function(internalInstance, transaction, updateBatchNumber) {
+            if (internalInstance._updateBatchNumber !== updateBatchNumber) return void warning(null == internalInstance._updateBatchNumber || internalInstance._updateBatchNumber === updateBatchNumber + 1, "performUpdateIfNecessary: Unexpected batch number (current %s, " + "pending %s)", updateBatchNumber, internalInstance._updateBatchNumber);
+            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement), 
+            internalInstance.performUpdateIfNecessary(transaction), 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
+        }
+    }, ReactReconciler_1 = ReactReconciler, ReactInstanceMap = {
+        remove: function(key) {
+            key._reactInternalInstance = void 0;
+        },
+        get: function(key) {
+            return key._reactInternalInstance;
+        },
+        has: function(key) {
+            return void 0 !== key._reactInternalInstance;
+        },
+        set: function(key, value) {
+            key._reactInternalInstance = value;
+        }
+    }, ReactInstanceMap_1 = ReactInstanceMap, oneArgumentPooler = function(copyFieldsFrom) {
+        var Klass = this;
+        if (Klass.instancePool.length) {
+            var instance = Klass.instancePool.pop();
+            return Klass.call(instance, copyFieldsFrom), instance;
+        }
+        return new Klass(copyFieldsFrom);
+    }, twoArgumentPooler = function(a1, a2) {
+        var Klass = this;
+        if (Klass.instancePool.length) {
+            var instance = Klass.instancePool.pop();
+            return Klass.call(instance, a1, a2), instance;
+        }
+        return new Klass(a1, a2);
+    }, threeArgumentPooler = function(a1, a2, a3) {
+        var Klass = this;
+        if (Klass.instancePool.length) {
+            var instance = Klass.instancePool.pop();
+            return Klass.call(instance, a1, a2, a3), instance;
+        }
+        return new Klass(a1, a2, a3);
+    }, fourArgumentPooler = function(a1, a2, a3, a4) {
+        var Klass = this;
+        if (Klass.instancePool.length) {
+            var instance = Klass.instancePool.pop();
+            return Klass.call(instance, a1, a2, a3, a4), instance;
+        }
+        return new Klass(a1, a2, a3, a4);
+    }, standardReleaser = function(instance) {
+        var Klass = this;
+        invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
+        instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
+    }, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
+        var NewKlass = CopyConstructor;
+        return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
+        NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
+        NewKlass;
+    }, PooledClass = {
+        addPoolingTo: addPoolingTo,
+        oneArgumentPooler: oneArgumentPooler,
+        twoArgumentPooler: twoArgumentPooler,
+        threeArgumentPooler: threeArgumentPooler,
+        fourArgumentPooler: fourArgumentPooler
+    }, PooledClass_1 = PooledClass, OBSERVED_ERROR = {}, TransactionImpl = {
+        reinitializeTransaction: function() {
+            this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], 
+            this._isInTransaction = !1;
+        },
+        _isInTransaction: !1,
+        getTransactionWrappers: null,
+        isInTransaction: function() {
+            return !!this._isInTransaction;
+        },
+        perform: function(method, scope, a, b, c, d, e, f) {
+            invariant(!this.isInTransaction(), "Transaction.perform(...): Cannot initialize a transaction when there " + "is already an outstanding transaction.");
+            var errorThrown, ret;
+            try {
+                this._isInTransaction = !0, errorThrown = !0, this.initializeAll(0), ret = method.call(scope, a, b, c, d, e, f), 
+                errorThrown = !1;
+            } finally {
+                try {
+                    if (errorThrown) try {
+                        this.closeAll(0);
+                    } catch (err) {} else this.closeAll(0);
+                } finally {
+                    this._isInTransaction = !1;
+                }
+            }
+            return ret;
+        },
+        initializeAll: function(startIndex) {
+            for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) {
+                var wrapper = transactionWrappers[i];
+                try {
+                    this.wrapperInitData[i] = OBSERVED_ERROR, this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
+                } finally {
+                    if (this.wrapperInitData[i] === OBSERVED_ERROR) try {
+                        this.initializeAll(i + 1);
+                    } catch (err) {}
+                }
+            }
+        },
+        closeAll: function(startIndex) {
+            invariant(this.isInTransaction(), "Transaction.closeAll(): Cannot close transaction when none are open.");
+            for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) {
+                var errorThrown, wrapper = transactionWrappers[i], initData = this.wrapperInitData[i];
+                try {
+                    errorThrown = !0, initData !== OBSERVED_ERROR && wrapper.close && wrapper.close.call(this, initData), 
+                    errorThrown = !1;
+                } finally {
+                    if (errorThrown) try {
+                        this.closeAll(i + 1);
+                    } catch (e) {}
+                }
+            }
+            this.wrapperInitData.length = 0;
+        }
+    }, Transaction = TransactionImpl, dirtyComponents = [], updateBatchNumber = 0, batchingStrategy = null;
+    function ensureInjected() {
+        invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy, "ReactUpdates: must inject a reconcile transaction class and batching " + "strategy");
     }
-    return !1;
-}
-
-function getParentInstance(inst) {
-    return getParent(inst);
-}
-
-function traverseTwoPhase(inst, fn, arg) {
-    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
-    var i;
-    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
-    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
-}
-
-function traverseEnterLeave(from, to, fn, argFrom, argTo) {
-    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
-    from = getParent(from);
-    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
-    var i;
-    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
-    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
-}
-
-var ReactTreeTraversal = {
-    isAncestor: isAncestor,
-    getLowestCommonAncestor: getLowestCommonAncestor,
-    getParentInstance: getParentInstance,
-    traverseTwoPhase: traverseTwoPhase,
-    traverseEnterLeave: traverseEnterLeave
-}, getListener = EventPluginHub_1.getListener;
-
-function listenerAtPhase(inst, event, propagationPhase) {
-    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
-    return getListener(inst, registrationName);
-}
-
-function accumulateDirectionalDispatches(inst, phase, event) {
-    warning(inst, "Dispatching inst must not be null");
-    var listener = listenerAtPhase(inst, event, phase);
-    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-}
-
-function accumulateTwoPhaseDispatchesSingle(event) {
-    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
-}
-
-function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
-    if (event && event.dispatchConfig.phasedRegistrationNames) {
-        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
-        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+    var NESTED_UPDATES = {
+        initialize: function() {
+            this.dirtyComponentsLength = dirtyComponents.length;
+        },
+        close: function() {
+            this.dirtyComponentsLength !== dirtyComponents.length ? (dirtyComponents.splice(0, this.dirtyComponentsLength), 
+            flushBatchedUpdates()) : dirtyComponents.length = 0;
+        }
+    }, TRANSACTION_WRAPPERS = [ NESTED_UPDATES ];
+    function ReactUpdatesFlushTransaction() {
+        this.reinitializeTransaction(), this.dirtyComponentsLength = null, this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(!0);
     }
-}
+    Object.assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
+        getTransactionWrappers: function() {
+            return TRANSACTION_WRAPPERS;
+        },
+        destructor: function() {
+            this.dirtyComponentsLength = null, ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction), 
+            this.reconcileTransaction = null;
+        },
+        perform: function(method, scope, a) {
+            return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
+        }
+    }), PooledClass_1.addPoolingTo(ReactUpdatesFlushTransaction);
+    function batchedUpdates(callback, a, b, c, d, e) {
+        return ensureInjected(), batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
+    }
+    function mountOrderComparator(c1, c2) {
+        return c1._mountOrder - c2._mountOrder;
+    }
+    function runBatchedUpdates(transaction) {
+        var len = transaction.dirtyComponentsLength;
+        invariant(len === dirtyComponents.length, "Expected flush transaction's stored dirty-components length (%s) to " + "match dirty-components array length (%s).", len, dirtyComponents.length), 
+        dirtyComponents.sort(mountOrderComparator), updateBatchNumber++;
+        for (var i = 0; i < len; i++) {
+            var component = dirtyComponents[i];
+            ReactReconciler_1.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
+        }
+    }
+    var flushBatchedUpdates = function() {
+        for (;dirtyComponents.length; ) {
+            var transaction = ReactUpdatesFlushTransaction.getPooled();
+            transaction.perform(runBatchedUpdates, null, transaction), ReactUpdatesFlushTransaction.release(transaction);
+        }
+    };
+    function enqueueUpdate$1(component) {
+        if (ensureInjected(), !batchingStrategy.isBatchingUpdates) return void batchingStrategy.batchedUpdates(enqueueUpdate$1, component);
+        dirtyComponents.push(component), null == component._updateBatchNumber && (component._updateBatchNumber = updateBatchNumber + 1);
+    }
+    var ReactUpdatesInjection = {
+        injectReconcileTransaction: function(ReconcileTransaction) {
+            invariant(ReconcileTransaction, "ReactUpdates: must provide a reconcile transaction class"), 
+            ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
+        },
+        injectBatchingStrategy: function(_batchingStrategy) {
+            invariant(_batchingStrategy, "ReactUpdates: must provide a batching strategy"), 
+            invariant("function" == typeof _batchingStrategy.batchedUpdates, "ReactUpdates: must provide a batchedUpdates() function"), 
+            invariant("boolean" == typeof _batchingStrategy.isBatchingUpdates, "ReactUpdates: must provide an isBatchingUpdates boolean attribute"), 
+            batchingStrategy = _batchingStrategy;
+        },
+        getBatchingStrategy: function() {
+            return batchingStrategy;
+        }
+    }, ReactUpdates = {
+        ReactReconcileTransaction: null,
+        batchedUpdates: batchedUpdates,
+        enqueueUpdate: enqueueUpdate$1,
+        flushBatchedUpdates: flushBatchedUpdates,
+        injection: ReactUpdatesInjection
+    }, ReactUpdates_1 = ReactUpdates, ReactCurrentOwner = ReactGlobalSharedState_1.ReactCurrentOwner, warning$5 = warning, warnOnInvalidCallback = function(callback, callerName) {
+        warning$5(null === callback || "function" == typeof callback, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, "" + callback);
+    };
+    function enqueueUpdate(internalInstance) {
+        ReactUpdates_1.enqueueUpdate(internalInstance);
+    }
+    function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
+        var internalInstance = ReactInstanceMap_1.get(publicInstance);
+        if (!internalInstance) {
+            var ctor = publicInstance.constructor;
+            return warning$5(!1, "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.", ctor && (ctor.displayName || ctor.name) || "ReactClass"), 
+            null;
+        }
+        return warning$5(null == ReactCurrentOwner.current, "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`."), 
+        internalInstance;
+    }
+    var ReactUpdateQueue = {
+        isMounted: function(publicInstance) {
+            var owner = ReactCurrentOwner.current;
+            null !== owner && (warning$5(owner._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.", owner.getName() || "A component"), 
+            owner._warnedAboutRefsInRender = !0);
+            var internalInstance = ReactInstanceMap_1.get(publicInstance);
+            return !!internalInstance && !!internalInstance._renderedComponent;
+        },
+        enqueueCallbackInternal: function(internalInstance, callback) {
+            internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ], 
+            enqueueUpdate(internalInstance);
+        },
+        enqueueForceUpdate: function(publicInstance, callback, callerName) {
+            var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
+            internalInstance && (callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
+            internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
+            internalInstance._pendingForceUpdate = !0, enqueueUpdate(internalInstance));
+        },
+        enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
+            var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
+            internalInstance && (internalInstance._pendingStateQueue = [ completeState ], internalInstance._pendingReplaceState = !0, 
+            callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
+            internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
+            enqueueUpdate(internalInstance));
+        },
+        enqueueSetState: function(publicInstance, partialState, callback, callerName) {
+            ReactInstrumentation.debugTool.onSetState(), warning$5(null != partialState, "setState(...): You passed an undefined or null state object; " + "instead, use forceUpdate().");
+            var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
+            if (internalInstance) {
+                (internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = [])).push(partialState), 
+                callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
+                internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
+                enqueueUpdate(internalInstance);
+            }
+        },
+        enqueueElementInternal: function(internalInstance, nextElement, nextContext) {
+            internalInstance._pendingElement = nextElement, internalInstance._context = nextContext, 
+            enqueueUpdate(internalInstance);
+        }
+    }, ReactUpdateQueue_1 = ReactUpdateQueue, injected = !1, ReactComponentEnvironment = {
+        replaceNodeWithMarkup: null,
+        processChildrenUpdates: null,
+        injection: {
+            injectEnvironment: function(environment) {
+                invariant(!injected, "ReactCompositeComponent: injectEnvironment() can only be called once."), 
+                ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup, 
+                ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates, 
+                injected = !0;
+            }
+        }
+    }, ReactComponentEnvironment_1 = ReactComponentEnvironment, ReactErrorUtils = {
+        _caughtError: null,
+        _hasCaughtError: !1,
+        _rethrowError: null,
+        _hasRethrowError: !1,
+        injection: {
+            injectErrorUtils: function(injectedErrorUtils) {
+                invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
+                invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
+            }
+        },
+        invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
+            invokeGuardedCallback.apply(ReactErrorUtils, arguments);
+        },
+        invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
+            if (ReactErrorUtils.invokeGuardedCallback.apply(this, arguments), ReactErrorUtils.hasCaughtError()) {
+                var error = ReactErrorUtils.clearCaughtError();
+                ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
+            }
+        },
+        rethrowCaughtError: function() {
+            return rethrowCaughtError.apply(ReactErrorUtils, arguments);
+        },
+        hasCaughtError: function() {
+            return ReactErrorUtils._hasCaughtError;
+        },
+        clearCaughtError: function() {
+            if (ReactErrorUtils._hasCaughtError) {
+                var error = ReactErrorUtils._caughtError;
+                return ReactErrorUtils._caughtError = null, ReactErrorUtils._hasCaughtError = !1, 
+                error;
+            }
+            invariant(!1, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
+        }
+    }, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+        ReactErrorUtils._hasCaughtError = !1, ReactErrorUtils._caughtError = null;
+        var funcArgs = Array.prototype.slice.call(arguments, 3);
+        try {
+            func.apply(context, funcArgs);
+        } catch (error) {
+            ReactErrorUtils._caughtError = error, ReactErrorUtils._hasCaughtError = !0;
+        }
+    };
+    if ("undefined" != typeof window && "function" == typeof window.dispatchEvent && "undefined" != typeof document && "function" == typeof document.createEvent) {
+        var fakeNode = document.createElement("react");
+        invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+            var didError = !0, funcArgs = Array.prototype.slice.call(arguments, 3);
+            function callCallback() {
+                fakeNode.removeEventListener(evtType, callCallback, !1), func.apply(context, funcArgs), 
+                didError = !1;
+            }
+            var error = void 0, didSetError = !1, isCrossOriginError = !1;
+            function onError(event) {
+                error = event.error, didSetError = !0, null === error && 0 === event.colno && 0 === event.lineno && (isCrossOriginError = !0);
+            }
+            var evtType = "react-" + (name || "invokeguardedcallback");
+            window.addEventListener("error", onError), fakeNode.addEventListener(evtType, callCallback, !1);
+            var evt = document.createEvent("Event");
+            evt.initEvent(evtType, !1, !1), fakeNode.dispatchEvent(evt), didError ? (didSetError ? isCrossOriginError && (error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error because it catches errors using a global " + 'error handler, in order to preserve the "Pause on exceptions" ' + "behavior of the DevTools. This is only an issue in DEV-mode; " + "in production, React uses a normal try-catch statement.\n\n" + "If you are using React from a CDN, ensure that the <script> tag " + "has a `crossorigin` attribute, and that it is served with the " + "`Access-Control-Allow-Origin: *` HTTP header. " + "See https://fb.me/react-cdn-crossorigin")) : 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."), 
+            ReactErrorUtils._hasCaughtError = !0, ReactErrorUtils._caughtError = error) : (ReactErrorUtils._hasCaughtError = !1, 
+            ReactErrorUtils._caughtError = null), window.removeEventListener("error", onError);
+        };
+    }
+    var rethrowCaughtError = function() {
+        if (ReactErrorUtils._hasRethrowError) {
+            var error = ReactErrorUtils._rethrowError;
+            throw ReactErrorUtils._rethrowError = null, ReactErrorUtils._hasRethrowError = !1, 
+            error;
+        }
+    }, ReactErrorUtils_1 = ReactErrorUtils, ReactNodeTypes = {
+        HOST: 0,
+        COMPOSITE: 1,
+        EMPTY: 2,
+        getType: function(node) {
+            return null === node || !1 === node ? ReactNodeTypes.EMPTY : React.isValidElement(node) ? "function" == typeof node.type ? ReactNodeTypes.COMPOSITE : ReactNodeTypes.HOST : void invariant(!1, "Unexpected node: %s", node);
+        }
+    }, ReactNodeTypes_1 = ReactNodeTypes, ReactDebugCurrentStack$1 = {}, _require$2 = ReactGlobalSharedState_1, ReactComponentTreeHook$2 = _require$2.ReactComponentTreeHook, getStackAddendumByID = ReactComponentTreeHook$2.getStackAddendumByID, getCurrentStackAddendum = ReactComponentTreeHook$2.getCurrentStackAddendum;
+    ReactDebugCurrentStack$1.current = null, ReactDebugCurrentStack$1.getStackAddendum = function() {
+        var current = ReactDebugCurrentStack$1.current;
+        return null !== current ? getStackAddendumByID(current) : getCurrentStackAddendum();
+    };
+    var ReactDebugCurrentStack_1 = ReactDebugCurrentStack$1;
+    function shouldUpdateReactComponent(prevElement, nextElement) {
+        var prevEmpty = null === prevElement || !1 === prevElement, nextEmpty = null === nextElement || !1 === nextElement;
+        if (prevEmpty || nextEmpty) return prevEmpty === nextEmpty;
+        var prevType = typeof prevElement, nextType = typeof nextElement;
+        return "string" === prevType || "number" === prevType ? "string" === nextType || "number" === nextType : "object" === nextType && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
+    }
+    var shouldUpdateReactComponent_1 = shouldUpdateReactComponent, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, _require2 = ReactGlobalSharedState_1, ReactDebugCurrentFrame = _require2.ReactDebugCurrentFrame, ReactDebugCurrentStack = ReactDebugCurrentStack_1, warningAboutMissingGetChildContext = {};
+    function StatelessComponent(Component) {}
+    StatelessComponent.prototype.render = function() {
+        return (0, ReactInstanceMap_1.get(this)._currentElement.type)(this.props, this.context, this.updater);
+    };
+    function shouldConstruct(Component) {
+        return !(!Component.prototype || !Component.prototype.isReactComponent);
+    }
+    function isPureComponent(Component) {
+        return !(!Component.prototype || !Component.prototype.isPureReactComponent);
+    }
+    function measureLifeCyclePerf(fn, debugID, timerType) {
+        if (0 === debugID) return fn();
+        ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);
+        try {
+            return fn();
+        } finally {
+            ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);
+        }
+    }
+    var emptyComponentFactory, nextMountID = 1, ReactCompositeComponent = {
+        construct: function(element) {
+            this._currentElement = element, this._rootNodeID = 0, this._compositeType = null, 
+            this._instance = null, this._hostParent = null, this._hostContainerInfo = null, 
+            this._updateBatchNumber = null, this._pendingElement = null, this._pendingStateQueue = null, 
+            this._pendingReplaceState = !1, this._pendingForceUpdate = !1, this._renderedNodeType = null, 
+            this._renderedComponent = null, this._context = null, this._mountOrder = 0, this._topLevelWrapper = null, 
+            this._pendingCallbacks = null, this._calledComponentWillUnmount = !1, this._warnedAboutRefsInRender = !1;
+        },
+        mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
+            var _this = this;
+            this._context = context, this._mountOrder = nextMountID++, this._hostParent = hostParent, 
+            this._hostContainerInfo = hostContainerInfo;
+            var renderedElement, publicProps = this._currentElement.props, publicContext = this._processContext(context), Component = this._currentElement.type, updateQueue = transaction.getUpdateQueue(), doConstruct = shouldConstruct(Component), inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);
+            doConstruct || null != inst && null != inst.render ? isPureComponent(Component) ? this._compositeType = ReactCompositeComponentTypes$1.PureClass : this._compositeType = ReactCompositeComponentTypes$1.ImpureClass : (renderedElement = inst, 
+            warning(!Component.childContextTypes, "%s(...): childContextTypes cannot be defined on a functional component.", Component.displayName || Component.name || "Component"), 
+            invariant(null === inst || !1 === inst || React.isValidElement(inst), "%s(...): A valid React element (or null) must be returned. You may have " + "returned undefined, an array or some other invalid object.", Component.displayName || Component.name || "Component"), 
+            inst = new StatelessComponent(Component), this._compositeType = ReactCompositeComponentTypes$1.StatelessFunctional), 
+            null == inst.render && warning(!1, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", Component.displayName || Component.name || "Component");
+            var propsMutated = inst.props !== publicProps, componentName = Component.displayName || Component.name || "Component";
+            warning(void 0 === inst.props || !propsMutated, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", componentName, componentName), 
+            inst.props = publicProps, inst.context = publicContext, inst.refs = emptyObject, 
+            inst.updater = updateQueue, this._instance = inst, ReactInstanceMap_1.set(inst, this), 
+            warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved || inst.state, "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?", this.getName() || "a component"), 
+            warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, "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.", this.getName() || "a component"), 
+            warning(!inst.propTypes, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", this.getName() || "a component"), 
+            warning(!inst.contextTypes, "contextTypes was defined as an instance property on %s. Use a " + "static property to define contextTypes instead.", this.getName() || "a component"), 
+            warning("function" != typeof inst.componentShouldUpdate, "%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.", this.getName() || "A component"), 
+            warning("function" != typeof inst.componentDidUnmount, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", this.getName() || "A component"), 
+            warning("function" != typeof inst.componentWillRecieveProps, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", this.getName() || "A component"), 
+            isPureComponent(Component) && void 0 !== inst.shouldComponentUpdate && warning(!1, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", this.getName() || "A pure component"), 
+            warning(!inst.defaultProps, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", this.getName() || "a component", this.getName() || "a component");
+            var initialState = inst.state;
+            void 0 === initialState && (inst.state = initialState = null), invariant("object" == typeof initialState && !Array.isArray(initialState), "%s.state: must be set to an object or null", this.getName() || "ReactCompositeComponent"), 
+            this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, 
+            inst.componentWillMount && (measureLifeCyclePerf(function() {
+                return inst.componentWillMount();
+            }, this._debugID, "componentWillMount"), this._pendingStateQueue && (inst.state = this._processPendingState(inst.props, inst.context)));
+            var markup;
+            markup = inst.componentDidCatch ? this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context) : this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context), 
+            inst.componentDidMount && transaction.getReactMountReady().enqueue(function() {
+                measureLifeCyclePerf(function() {
+                    return inst.componentDidMount();
+                }, _this._debugID, "componentDidMount");
+            });
+            var callbacks = this._pendingCallbacks;
+            if (callbacks) {
+                this._pendingCallbacks = null;
+                for (var i = 0; i < callbacks.length; i++) transaction.getReactMountReady().enqueue(callbacks[i], inst);
+            }
+            return markup;
+        },
+        _constructComponent: function(doConstruct, publicProps, publicContext, updateQueue) {
+            ReactCurrentOwner$1.current = this, ReactDebugCurrentFrame.getCurrentStack = ReactDebugCurrentStack.getStackAddendum;
+            try {
+                return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
+            } finally {
+                ReactCurrentOwner$1.current = null, ReactDebugCurrentFrame.getCurrentStack = null;
+            }
+        },
+        _constructComponentWithoutOwner: function(doConstruct, publicProps, publicContext, updateQueue) {
+            var Component = this._currentElement.type;
+            return doConstruct ? measureLifeCyclePerf(function() {
+                return new Component(publicProps, publicContext, updateQueue);
+            }, this._debugID, "ctor") : measureLifeCyclePerf(function() {
+                return Component(publicProps, publicContext, updateQueue);
+            }, this._debugID, "render");
+        },
+        performInitialMountWithErrorHandling: function(renderedElement, hostParent, hostContainerInfo, transaction, context) {
+            var markup, checkpoint = transaction.checkpoint();
+            try {
+                markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
+            } catch (e) {
+                transaction.rollback(checkpoint), this._instance.componentDidCatch(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
+                checkpoint = transaction.checkpoint(), this._renderedComponent.unmountComponent(!0, !0), 
+                transaction.rollback(checkpoint), markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
+            }
+            return markup;
+        },
+        performInitialMount: function(renderedElement, hostParent, hostContainerInfo, transaction, context) {
+            void 0 === renderedElement && (renderedElement = this._renderValidatedComponent());
+            var nodeType = ReactNodeTypes_1.getType(renderedElement);
+            this._renderedNodeType = nodeType;
+            var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes_1.EMPTY);
+            this._renderedComponent = child;
+            var debugID = 0;
+            debugID = this._debugID;
+            var markup = ReactReconciler_1.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);
+            if (0 !== debugID) {
+                var childDebugIDs = 0 !== child._debugID ? [ child._debugID ] : [];
+                ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
+            }
+            return markup;
+        },
+        getHostNode: function() {
+            return ReactReconciler_1.getHostNode(this._renderedComponent);
+        },
+        unmountComponent: function(safely, skipLifecycle) {
+            if (this._renderedComponent) {
+                var inst = this._instance;
+                if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) if (inst._calledComponentWillUnmount = !0, 
+                safely) {
+                    if (!skipLifecycle) {
+                        var name = this.getName() + ".componentWillUnmount()";
+                        ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(name, inst.componentWillUnmount, inst);
+                    }
+                } else measureLifeCyclePerf(function() {
+                    return inst.componentWillUnmount();
+                }, this._debugID, "componentWillUnmount");
+                this._renderedComponent && (ReactReconciler_1.unmountComponent(this._renderedComponent, safely, skipLifecycle), 
+                this._renderedNodeType = null, this._renderedComponent = null, this._instance = null), 
+                this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, 
+                this._pendingCallbacks = null, this._pendingElement = null, this._context = null, 
+                this._rootNodeID = 0, this._topLevelWrapper = null, ReactInstanceMap_1.remove(inst);
+            }
+        },
+        _maskContext: function(context) {
+            var Component = this._currentElement.type, contextTypes = Component.contextTypes;
+            if (!contextTypes) return emptyObject;
+            var maskedContext = {};
+            for (var contextName in contextTypes) maskedContext[contextName] = context[contextName];
+            return maskedContext;
+        },
+        _processContext: function(context) {
+            var maskedContext = this._maskContext(context), Component = this._currentElement.type;
+            return Component.contextTypes && this._checkContextTypes(Component.contextTypes, maskedContext, "context"), 
+            maskedContext;
+        },
+        _processChildContext: function(currentContext) {
+            var childContext, Component = this._currentElement.type, inst = this._instance;
+            if ("function" == typeof inst.getChildContext) {
+                ReactInstrumentation.debugTool.onBeginProcessingChildContext();
+                try {
+                    childContext = inst.getChildContext();
+                } finally {
+                    ReactInstrumentation.debugTool.onEndProcessingChildContext();
+                }
+                invariant("object" == typeof Component.childContextTypes, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", this.getName() || "ReactCompositeComponent"), 
+                this._checkContextTypes(Component.childContextTypes, childContext, "child context");
+                for (var name in childContext) invariant(name in Component.childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || "ReactCompositeComponent", name);
+                return Object.assign({}, currentContext, childContext);
+            }
+            var componentName = this.getName();
+            return warningAboutMissingGetChildContext[componentName] || (warningAboutMissingGetChildContext[componentName] = !0, 
+            warning(!Component.childContextTypes, "%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)), 
+            currentContext;
+        },
+        _checkContextTypes: function(typeSpecs, values, location) {
+            ReactDebugCurrentStack.current = this._debugID, checkPropTypes(typeSpecs, values, location, this.getName(), ReactDebugCurrentStack.getStackAddendum), 
+            ReactDebugCurrentStack.current = null;
+        },
+        receiveComponent: function(nextElement, transaction, nextContext) {
+            var prevElement = this._currentElement, prevContext = this._context;
+            this._pendingElement = null, this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
+        },
+        performUpdateIfNecessary: function(transaction) {
+            if (null != this._pendingElement) ReactReconciler_1.receiveComponent(this, this._pendingElement, transaction, this._context); else if (null !== this._pendingStateQueue || this._pendingForceUpdate) this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context); else {
+                var callbacks = this._pendingCallbacks;
+                if (this._pendingCallbacks = null, callbacks) for (var j = 0; j < callbacks.length; j++) transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
+                this._updateBatchNumber = null;
+            }
+        },
+        updateComponent: function(transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
+            var inst = this._instance;
+            invariant(null != inst, "Attempted to update component `%s` that has already been unmounted " + "(or failed to mount).", this.getName() || "ReactCompositeComponent");
+            var nextContext, willReceive = !1;
+            this._context === nextUnmaskedContext ? nextContext = inst.context : (nextContext = this._processContext(nextUnmaskedContext), 
+            willReceive = !0);
+            var prevProps = prevParentElement.props, nextProps = nextParentElement.props;
+            if (prevParentElement !== nextParentElement && (willReceive = !0), willReceive && inst.componentWillReceiveProps) {
+                var beforeState = inst.state;
+                measureLifeCyclePerf(function() {
+                    return inst.componentWillReceiveProps(nextProps, nextContext);
+                }, this._debugID, "componentWillReceiveProps");
+                var afterState = inst.state;
+                beforeState !== afterState && (inst.state = beforeState, inst.updater.enqueueReplaceState(inst, afterState), 
+                warning(!1, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", this.getName() || "ReactCompositeComponent"));
+            }
+            var callbacks = this._pendingCallbacks;
+            this._pendingCallbacks = null;
+            var nextState = this._processPendingState(nextProps, nextContext), shouldUpdate = !0;
+            if (!this._pendingForceUpdate) {
+                var prevState = inst.state;
+                shouldUpdate = willReceive || nextState !== prevState, inst.shouldComponentUpdate ? shouldUpdate = measureLifeCyclePerf(function() {
+                    return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
+                }, this._debugID, "shouldComponentUpdate") : this._compositeType === ReactCompositeComponentTypes$1.PureClass && (shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState));
+            }
+            if (warning(void 0 !== shouldUpdate, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", this.getName() || "ReactCompositeComponent"), 
+            this._updateBatchNumber = null, shouldUpdate ? (this._pendingForceUpdate = !1, this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext)) : (this._currentElement = nextParentElement, 
+            this._context = nextUnmaskedContext, inst.props = nextProps, inst.state = nextState, 
+            inst.context = nextContext), callbacks) for (var j = 0; j < callbacks.length; j++) transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
+        },
+        _processPendingState: function(props, context) {
+            var inst = this._instance, queue = this._pendingStateQueue, replace = this._pendingReplaceState;
+            if (this._pendingReplaceState = !1, this._pendingStateQueue = null, !queue) return inst.state;
+            if (replace && 1 === queue.length) return queue[0];
+            for (var nextState = replace ? queue[0] : inst.state, dontMutate = !0, i = replace ? 1 : 0; i < queue.length; i++) {
+                var partial = queue[i], partialState = "function" == typeof partial ? partial.call(inst, nextState, props, context) : partial;
+                partialState && (dontMutate ? (dontMutate = !1, nextState = Object.assign({}, nextState, partialState)) : Object.assign(nextState, partialState));
+            }
+            return nextState;
+        },
+        _performComponentUpdate: function(nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
+            var prevProps, prevState, _this2 = this, inst = this._instance, hasComponentDidUpdate = !!inst.componentDidUpdate;
+            hasComponentDidUpdate && (prevProps = inst.props, prevState = inst.state), inst.componentWillUpdate && measureLifeCyclePerf(function() {
+                return inst.componentWillUpdate(nextProps, nextState, nextContext);
+            }, this._debugID, "componentWillUpdate"), this._currentElement = nextElement, this._context = unmaskedContext, 
+            inst.props = nextProps, inst.state = nextState, inst.context = nextContext, inst.componentDidCatch ? this._updateRenderedComponentWithErrorHandling(transaction, unmaskedContext) : this._updateRenderedComponent(transaction, unmaskedContext), 
+            hasComponentDidUpdate && transaction.getReactMountReady().enqueue(function() {
+                measureLifeCyclePerf(inst.componentDidUpdate.bind(inst, prevProps, prevState), _this2._debugID, "componentDidUpdate");
+            });
+        },
+        _updateRenderedComponentWithErrorHandling: function(transaction, context) {
+            var checkpoint = transaction.checkpoint();
+            try {
+                this._updateRenderedComponent(transaction, context);
+            } catch (e) {
+                transaction.rollback(checkpoint), this._instance.componentDidCatch(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
+                checkpoint = transaction.checkpoint(), this._updateRenderedComponentWithNextElement(transaction, context, null, !0), 
+                this._updateRenderedComponent(transaction, context);
+            }
+        },
+        _updateRenderedComponent: function(transaction, context) {
+            var nextRenderedElement = this._renderValidatedComponent();
+            this._updateRenderedComponentWithNextElement(transaction, context, nextRenderedElement, !1);
+        },
+        _updateRenderedComponentWithNextElement: function(transaction, context, nextRenderedElement, safely) {
+            var prevComponentInstance = this._renderedComponent, prevRenderedElement = prevComponentInstance._currentElement, debugID = 0;
+            if (debugID = this._debugID, shouldUpdateReactComponent_1(prevRenderedElement, nextRenderedElement)) ReactReconciler_1.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context)); else {
+                var oldHostNode = ReactReconciler_1.getHostNode(prevComponentInstance), nodeType = ReactNodeTypes_1.getType(nextRenderedElement);
+                this._renderedNodeType = nodeType;
+                var child = this._instantiateReactComponent(nextRenderedElement, nodeType !== ReactNodeTypes_1.EMPTY);
+                this._renderedComponent = child;
+                var nextMarkup = ReactReconciler_1.mountComponent(child, transaction, this._hostParent, this._hostContainerInfo, this._processChildContext(context), debugID);
+                if (ReactReconciler_1.unmountComponent(prevComponentInstance, safely, !1), 0 !== debugID) {
+                    var childDebugIDs = 0 !== child._debugID ? [ child._debugID ] : [];
+                    ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
+                }
+                this._replaceNodeWithMarkup(oldHostNode, nextMarkup, prevComponentInstance);
+            }
+        },
+        _replaceNodeWithMarkup: function(oldHostNode, nextMarkup, prevInstance) {
+            ReactComponentEnvironment_1.replaceNodeWithMarkup(oldHostNode, nextMarkup, prevInstance);
+        },
+        _renderValidatedComponentWithoutOwnerOrContext: function() {
+            var renderedElement, inst = this._instance;
+            return renderedElement = measureLifeCyclePerf(function() {
+                return inst.render();
+            }, this._debugID, "render"), void 0 === renderedElement && inst.render._isMockFunction && (renderedElement = null), 
+            renderedElement;
+        },
+        _renderValidatedComponent: function() {
+            var renderedElement;
+            if (0 && this._compositeType === ReactCompositeComponentTypes$1.StatelessFunctional) renderedElement = this._renderValidatedComponentWithoutOwnerOrContext(); else {
+                ReactCurrentOwner$1.current = this, ReactDebugCurrentFrame.getCurrentStack = ReactDebugCurrentStack.getStackAddendum;
+                try {
+                    renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
+                } finally {
+                    ReactCurrentOwner$1.current = null, ReactDebugCurrentFrame.getCurrentStack = null;
+                }
+            }
+            return invariant(null === renderedElement || !1 === renderedElement || React.isValidElement(renderedElement), "%s.render(): A valid React element (or null) must be returned. You may have " + "returned undefined, an array or some other invalid object.", this.getName() || "ReactCompositeComponent"), 
+            renderedElement;
+        },
+        attachRef: function(ref, component) {
+            var inst = this.getPublicInstance();
+            invariant(null != inst, "Stateless function components cannot have refs.");
+            var publicComponentInstance = component.getPublicInstance();
+            (inst.refs === emptyObject ? inst.refs = {} : inst.refs)[ref] = publicComponentInstance;
+        },
+        detachRef: function(ref) {
+            delete this.getPublicInstance().refs[ref];
+        },
+        getName: function() {
+            var type = this._currentElement.type, constructor = this._instance && this._instance.constructor;
+            return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;
+        },
+        getPublicInstance: function() {
+            var inst = this._instance;
+            return this._compositeType === ReactCompositeComponentTypes$1.StatelessFunctional ? null : inst;
+        },
+        _instantiateReactComponent: null
+    }, ReactCompositeComponent_1 = ReactCompositeComponent, ReactEmptyComponentInjection = {
+        injectEmptyComponentFactory: function(factory) {
+            emptyComponentFactory = factory;
+        }
+    }, ReactEmptyComponent = {
+        create: function(instantiate) {
+            return emptyComponentFactory(instantiate);
+        }
+    };
+    ReactEmptyComponent.injection = ReactEmptyComponentInjection;
+    var ReactEmptyComponent_1 = ReactEmptyComponent, genericComponentClass = null, textComponentClass = null, ReactHostComponentInjection = {
+        injectGenericComponentClass: function(componentClass) {
+            genericComponentClass = componentClass;
+        },
+        injectTextComponentClass: function(componentClass) {
+            textComponentClass = componentClass;
+        }
+    };
+    function createInternalComponent(element) {
+        return invariant(genericComponentClass, "There is no registered component for the tag %s", element.type), 
+        new genericComponentClass(element);
+    }
+    function createInstanceForText(text) {
+        return new textComponentClass(text);
+    }
+    function isTextComponent(component) {
+        return component instanceof textComponentClass;
+    }
+    var ReactHostComponent = {
+        createInternalComponent: createInternalComponent,
+        createInstanceForText: createInstanceForText,
+        isTextComponent: isTextComponent,
+        injection: ReactHostComponentInjection
+    }, ReactHostComponent_1 = ReactHostComponent, nextDebugID = 1, ReactCompositeComponentWrapper = function(element) {
+        this.construct(element);
+    };
+    function getDeclarationErrorAddendum(owner) {
+        if (owner) {
+            var name = owner.getName();
+            if (name) return "\n\nCheck the render method of `" + name + "`.";
+        }
+        return "";
+    }
+    function isInternalComponentType(type) {
+        return "function" == typeof type && void 0 !== type.prototype && "function" == typeof type.prototype.mountComponent && "function" == typeof type.prototype.receiveComponent;
+    }
+    function instantiateReactComponent(node, shouldHaveDebugID) {
+        var instance;
+        if (null === node || !1 === node) instance = ReactEmptyComponent_1.create(instantiateReactComponent); else if ("object" == typeof node) {
+            var element = node, type = element.type;
+            if ("function" != typeof type && "string" != typeof type) {
+                var info = "";
+                (void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file " + "it's defined in."), 
+                info += getDeclarationErrorAddendum(element._owner), invariant(!1, "Element type is invalid: expected a string (for built-in components) " + "or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info);
+            }
+            "string" == typeof element.type ? instance = ReactHostComponent_1.createInternalComponent(element) : isInternalComponentType(element.type) ? (instance = new element.type(element), 
+            instance.getHostNode || (instance.getHostNode = instance.getNativeNode)) : instance = new ReactCompositeComponentWrapper(element);
+        } else "string" == typeof node || "number" == typeof node ? instance = ReactHostComponent_1.createInstanceForText(node) : invariant(!1, "Encountered invalid React node of type %s", typeof node);
+        return warning("function" == typeof instance.mountComponent && "function" == typeof instance.receiveComponent && "function" == typeof instance.getHostNode && "function" == typeof instance.unmountComponent, "Only React Components can be mounted."), 
+        instance._mountIndex = 0, instance._mountImage = null, instance._debugID = shouldHaveDebugID ? nextDebugID++ : 0, 
+        Object.preventExtensions && Object.preventExtensions(instance), instance;
+    }
+    Object.assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent_1, {
+        _instantiateReactComponent: instantiateReactComponent
+    });
+    var instantiateReactComponent_1 = instantiateReactComponent, DevOnlyStubShim = null, ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
+        return DevOnlyStubShim.findHostInstance(fiber);
+    } : function(instance) {
+        return instance;
+    };
+    function findNodeHandle(componentOrHandle) {
+        var owner = ReactCurrentOwner$2.current;
+        if (null !== owner && (warning(owner._warnedAboutRefsInRender, "%s is accessing findNodeHandle 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.", owner.getName() || "A component"), 
+        owner._warnedAboutRefsInRender = !0), null == componentOrHandle) return null;
+        if ("number" == typeof componentOrHandle) return componentOrHandle;
+        var component = componentOrHandle, internalInstance = ReactInstanceMap_1.get(component);
+        return internalInstance ? injectedFindNode(internalInstance) : component || (invariant("object" == typeof component && ("_rootNodeID" in component || "_nativeTag" in component) || null != component.render && "function" == typeof component.render, "findNodeHandle(...): Argument is not a component " + "(type: %s, keys: %s)", typeof component, Object.keys(component)), 
+        void invariant(!1, "findNodeHandle(...): Unable to find node handle for unmounted " + "component."));
+    }
+    var findNodeHandle_1 = findNodeHandle, TopLevelWrapper = function() {};
+    TopLevelWrapper.prototype.isReactComponent = {}, TopLevelWrapper.displayName = "TopLevelWrapper", 
+    TopLevelWrapper.prototype.render = function() {
+        return this.props.child;
+    }, TopLevelWrapper.isReactTopLevelWrapper = !0;
+    function mountComponentIntoNode(componentInstance, containerTag, transaction) {
+        var markup = ReactReconciler_1.mountComponent(componentInstance, transaction, null, ReactNativeContainerInfo_1(containerTag), emptyObject, 0);
+        componentInstance._renderedComponent._topLevelWrapper = componentInstance, ReactNativeMount._mountImageIntoNode(markup, containerTag);
+    }
+    function batchedMountComponentIntoNode(componentInstance, containerTag) {
+        var transaction = ReactUpdates_1.ReactReconcileTransaction.getPooled();
+        transaction.perform(mountComponentIntoNode, null, componentInstance, containerTag, transaction), 
+        ReactUpdates_1.ReactReconcileTransaction.release(transaction);
+    }
+    var ReactNativeMount = {
+        _instancesByContainerID: {},
+        findNodeHandle: findNodeHandle_1,
+        renderComponent: function(nextElement, containerTag, callback) {
+            var nextWrappedElement = React.createElement(TopLevelWrapper, {
+                child: nextElement
+            }), topRootNodeID = containerTag, prevComponent = ReactNativeMount._instancesByContainerID[topRootNodeID];
+            if (prevComponent) {
+                var prevWrappedElement = prevComponent._currentElement, prevElement = prevWrappedElement.props.child;
+                if (shouldUpdateReactComponent_1(prevElement, nextElement)) return ReactUpdateQueue_1.enqueueElementInternal(prevComponent, nextWrappedElement, emptyObject), 
+                callback && ReactUpdateQueue_1.enqueueCallbackInternal(prevComponent, callback), 
+                prevComponent;
+                ReactNativeMount.unmountComponentAtNode(containerTag);
+            }
+            if (!ReactNativeTagHandles_1.reactTagIsNativeTopRootID(containerTag)) return console.error("You cannot render into anything but a top root"), 
+            null;
+            ReactNativeTagHandles_1.assertRootTag(containerTag);
+            var instance = instantiateReactComponent_1(nextWrappedElement, !1);
+            if (ReactNativeMount._instancesByContainerID[containerTag] = instance, callback) {
+                var nonNullCallback = callback;
+                instance._pendingCallbacks = [ function() {
+                    nonNullCallback.call(instance._renderedComponent.getPublicInstance());
+                } ];
+            }
+            return ReactUpdates_1.batchedUpdates(batchedMountComponentIntoNode, instance, containerTag), 
+            instance._renderedComponent.getPublicInstance();
+        },
+        _mountImageIntoNode: function(mountImage, containerID) {
+            var childTag = mountImage;
+            UIManager.setChildren(containerID, [ childTag ]);
+        },
+        unmountComponentAtNodeAndRemoveContainer: function(containerTag) {
+            ReactNativeMount.unmountComponentAtNode(containerTag), UIManager.removeRootView(containerTag);
+        },
+        unmountComponentAtNode: function(containerTag) {
+            if (!ReactNativeTagHandles_1.reactTagIsNativeTopRootID(containerTag)) return console.error("You cannot render into anything but a top root"), 
+            !1;
+            var instance = ReactNativeMount._instancesByContainerID[containerTag];
+            return !!instance && (ReactInstrumentation.debugTool.onBeginFlush(), ReactNativeMount.unmountComponentFromNode(instance, containerTag), 
+            delete ReactNativeMount._instancesByContainerID[containerTag], ReactInstrumentation.debugTool.onEndFlush(), 
+            !0);
+        },
+        unmountComponentFromNode: function(instance, containerID) {
+            ReactReconciler_1.unmountComponent(instance), UIManager.removeSubviewsFromContainerWithID(containerID);
+        }
+    }, ReactNativeMount_1 = ReactNativeMount;
+    function getComponentName(instanceOrFiber) {
+        if ("function" == typeof instanceOrFiber.getName) {
+            return instanceOrFiber.getName();
+        }
+        if ("number" == typeof instanceOrFiber.tag) {
+            var fiber = instanceOrFiber, type = fiber.type;
+            if ("string" == typeof type) return type;
+            if ("function" == typeof type) return type.displayName || type.name;
+        }
+        return null;
+    }
+    var getComponentName_1 = getComponentName, getInspectorDataForViewTag = void 0, traverseOwnerTreeUp = function(hierarchy, instance) {
+        instance && (hierarchy.unshift(instance), traverseOwnerTreeUp(hierarchy, instance._currentElement._owner));
+    }, getOwnerHierarchy = function(instance) {
+        var hierarchy = [];
+        return traverseOwnerTreeUp(hierarchy, instance), hierarchy;
+    }, lastNotNativeInstance = function(hierarchy) {
+        for (var i = hierarchy.length - 1; i > 1; i--) {
+            var instance = hierarchy[i];
+            if (!instance.viewConfig) return instance;
+        }
+        return hierarchy[0];
+    }, getHostProps = function(component) {
+        var instance = component._instance;
+        return instance ? instance.props || emptyObject : emptyObject;
+    }, createHierarchy = function(componentHierarchy) {
+        return componentHierarchy.map(function(component) {
+            return {
+                name: getComponentName_1(component),
+                getInspectorData: function() {
+                    return {
+                        measure: function(callback) {
+                            return UIManager.measure(component.getHostNode(), callback);
+                        },
+                        props: getHostProps(component),
+                        source: component._currentElement && component._currentElement._source
+                    };
+                }
+            };
+        });
+    };
+    getInspectorDataForViewTag = function(viewTag) {
+        var component = ReactNativeComponentTree_1.getClosestInstanceFromNode(viewTag);
+        if (!component) return {
+            hierarchy: [],
+            props: emptyObject,
+            selection: null,
+            source: null
+        };
+        var componentHierarchy = getOwnerHierarchy(component), instance = lastNotNativeInstance(componentHierarchy), hierarchy = createHierarchy(componentHierarchy), props = getHostProps(instance), source = instance._currentElement && instance._currentElement._source;
+        return {
+            hierarchy: hierarchy,
+            props: props,
+            selection: componentHierarchy.indexOf(instance),
+            source: source
+        };
+    };
+    var ReactNativeStackInspector = {
+        getInspectorDataForViewTag: getInspectorDataForViewTag
+    }, findNumericNodeHandleStack = function(componentOrHandle) {
+        var nodeHandle = findNodeHandle_1(componentOrHandle);
+        return null == nodeHandle || "number" == typeof nodeHandle ? nodeHandle : nodeHandle.getHostNode();
+    }, eventPluginOrder = null, namesToPlugins = {};
+    function recomputePluginOrdering() {
+        if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+            var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
+            if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
+            !EventPluginRegistry.plugins[pluginIndex]) {
+                invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
+                EventPluginRegistry.plugins[pluginIndex] = pluginModule;
+                var publishedEvents = pluginModule.eventTypes;
+                for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
+            }
+        }
+    }
+    function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
+        invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
+        EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
+        var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+        if (phasedRegistrationNames) {
+            for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
+                var phasedRegistrationName = phasedRegistrationNames[phaseName];
+                publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+            }
+            return !0;
+        }
+        return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
+        !0);
+    }
+    function publishRegistrationName(registrationName, pluginModule, eventName) {
+        invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
+        EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
+        var lowerCasedName = registrationName.toLowerCase();
+        EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName, 
+        "onDoubleClick" === registrationName && (EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName);
+    }
+    var ComponentTree, EventPluginRegistry = {
+        plugins: [],
+        eventNameDispatchConfigs: {},
+        registrationNameModules: {},
+        registrationNameDependencies: {},
+        possibleRegistrationNames: {},
+        injectEventPluginOrder: function(injectedEventPluginOrder) {
+            invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
+            eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
+        },
+        injectEventPluginsByName: function(injectedNamesToPlugins) {
+            var isOrderingDirty = !1;
+            for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+                var pluginModule = injectedNamesToPlugins[pluginName];
+                namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
+                namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
+            }
+            isOrderingDirty && recomputePluginOrdering();
+        }
+    }, EventPluginRegistry_1 = EventPluginRegistry, warning$6 = warning, injection = {
+        injectComponentTree: function(Injected) {
+            ComponentTree = Injected, warning$6(Injected && Injected.getNodeFromInstance && Injected.getInstanceFromNode, "EventPluginUtils.injection.injectComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.");
+        }
+    };
+    function isEndish(topLevelType) {
+        return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
+    }
+    function isMoveish(topLevelType) {
+        return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
+    }
+    function isStartish(topLevelType) {
+        return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
+    }
+    var validateEventDispatches;
+    validateEventDispatches = function(event) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances, listenersIsArr = Array.isArray(dispatchListeners), listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0, instancesIsArr = Array.isArray(dispatchInstances), instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
+        warning$6(instancesIsArr === listenersIsArr && instancesLen === listenersLen, "EventPluginUtils: Invalid `event`.");
+    };
+    function executeDispatch(event, simulated, listener, inst) {
+        var type = event.type || "unknown-event";
+        event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
+        event.currentTarget = null;
+    }
+    function executeDispatchesInOrder(event, simulated) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+        if (validateEventDispatches(event), Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
+        event._dispatchListeners = null, event._dispatchInstances = null;
+    }
+    function executeDispatchesInOrderStopAtTrueImpl(event) {
+        var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+        if (validateEventDispatches(event), Array.isArray(dispatchListeners)) {
+            for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
+        } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
+        return null;
+    }
+    function executeDispatchesInOrderStopAtTrue(event) {
+        var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+        return event._dispatchInstances = null, event._dispatchListeners = null, ret;
+    }
+    function executeDirectDispatch(event) {
+        validateEventDispatches(event);
+        var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
+        invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
+        event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
+        var res = dispatchListener ? dispatchListener(event) : null;
+        return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
+        res;
+    }
+    function hasDispatches(event) {
+        return !!event._dispatchListeners;
+    }
+    var EventPluginUtils = {
+        isEndish: isEndish,
+        isMoveish: isMoveish,
+        isStartish: isStartish,
+        executeDirectDispatch: executeDirectDispatch,
+        executeDispatchesInOrder: executeDispatchesInOrder,
+        executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
+        hasDispatches: hasDispatches,
+        getFiberCurrentPropsFromNode: function(node) {
+            return ComponentTree.getFiberCurrentPropsFromNode(node);
+        },
+        getInstanceFromNode: function(node) {
+            return ComponentTree.getInstanceFromNode(node);
+        },
+        getNodeFromInstance: function(node) {
+            return ComponentTree.getNodeFromInstance(node);
+        },
+        injection: injection
+    }, EventPluginUtils_1 = EventPluginUtils;
+    function accumulateInto(current, next) {
+        return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
+        null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
+        current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+    }
+    var accumulateInto_1 = accumulateInto;
+    function forEachAccumulated(arr, cb, scope) {
+        Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+    }
+    var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
+        event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
+    }, executeDispatchesAndReleaseSimulated = function(e) {
+        return executeDispatchesAndRelease(e, !0);
+    }, executeDispatchesAndReleaseTopLevel = function(e) {
+        return executeDispatchesAndRelease(e, !1);
+    };
+    function isInteractive(tag) {
+        return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
+    }
+    function shouldPreventMouseEvent(name, type, props) {
+        switch (name) {
+          case "onClick":
+          case "onClickCapture":
+          case "onDoubleClick":
+          case "onDoubleClickCapture":
+          case "onMouseDown":
+          case "onMouseDownCapture":
+          case "onMouseMove":
+          case "onMouseMoveCapture":
+          case "onMouseUp":
+          case "onMouseUpCapture":
+            return !(!props.disabled || !isInteractive(type));
 
-function accumulateDispatches(inst, ignoredDirection, event) {
-    if (inst && event && event.dispatchConfig.registrationName) {
-        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+          default:
+            return !1;
+        }
+    }
+    var EventPluginHub = {
+        injection: {
+            injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
+            injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
+        },
+        getListener: function(inst, registrationName) {
+            var listener;
+            if ("number" == typeof inst.tag) {
+                var stateNode = inst.stateNode;
+                if (!stateNode) return null;
+                var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
+                if (!props) return null;
+                if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
+            } else {
+                var currentElement = inst._currentElement;
+                if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
+                if (!inst._rootNodeID) return null;
+                var _props = currentElement.props;
+                if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
+            }
+            return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
+            listener;
+        },
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
+                var possiblePlugin = plugins[i];
+                if (possiblePlugin) {
+                    var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+                    extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+                }
+            }
+            return events;
+        },
+        enqueueEvents: function(events) {
+            events && (eventQueue = accumulateInto_1(eventQueue, events));
+        },
+        processEventQueue: function(simulated) {
+            var processingEventQueue = eventQueue;
+            eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
+            invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
+            ReactErrorUtils_1.rethrowCaughtError();
+        }
+    }, EventPluginHub_1 = EventPluginHub, HostComponent = ReactTypeOfWork.HostComponent;
+    function getParent(inst) {
+        if (void 0 !== inst._hostParent) return inst._hostParent;
+        if ("number" == typeof inst.tag) {
+            do {
+                inst = inst.return;
+            } while (inst && inst.tag !== HostComponent);
+            if (inst) return inst;
+        }
+        return null;
+    }
+    function getLowestCommonAncestor(instA, instB) {
+        for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
+        for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
+        for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
+        for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
+        for (var depth = depthA; depth--; ) {
+            if (instA === instB || instA === instB.alternate) return instA;
+            instA = getParent(instA), instB = getParent(instB);
+        }
+        return null;
+    }
+    function isAncestor(instA, instB) {
+        for (;instB; ) {
+            if (instA === instB || instA === instB.alternate) return !0;
+            instB = getParent(instB);
+        }
+        return !1;
+    }
+    function getParentInstance(inst) {
+        return getParent(inst);
+    }
+    function traverseTwoPhase(inst, fn, arg) {
+        for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
+        var i;
+        for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
+        for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
+    }
+    function traverseEnterLeave(from, to, fn, argFrom, argTo) {
+        for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
+        from = getParent(from);
+        for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
+        var i;
+        for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
+        for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
+    }
+    var ReactTreeTraversal = {
+        isAncestor: isAncestor,
+        getLowestCommonAncestor: getLowestCommonAncestor,
+        getParentInstance: getParentInstance,
+        traverseTwoPhase: traverseTwoPhase,
+        traverseEnterLeave: traverseEnterLeave
+    }, getListener = EventPluginHub_1.getListener, warning$7 = warning;
+    function listenerAtPhase(inst, event, propagationPhase) {
+        var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+        return getListener(inst, registrationName);
+    }
+    function accumulateDirectionalDispatches(inst, phase, event) {
+        warning$7(inst, "Dispatching inst must not be null");
+        var listener = listenerAtPhase(inst, event, phase);
         listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
         event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
     }
-}
-
-function accumulateDirectDispatchesSingle(event) {
-    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
-}
-
-function accumulateTwoPhaseDispatches(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
-}
-
-function accumulateTwoPhaseDispatchesSkipTarget(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
-}
-
-function accumulateEnterLeaveDispatches(leave, enter, from, to) {
-    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
-}
-
-function accumulateDirectDispatches(events) {
-    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
-}
-
-var EventPropagators = {
-    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
-    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
-    accumulateDirectDispatches: accumulateDirectDispatches,
-    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
-}, EventPropagators_1 = EventPropagators, oneArgumentPooler = function(copyFieldsFrom) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, copyFieldsFrom), instance;
+    function accumulateTwoPhaseDispatchesSingle(event) {
+        event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
     }
-    return new Klass(copyFieldsFrom);
-}, twoArgumentPooler = function(a1, a2) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2), instance;
-    }
-    return new Klass(a1, a2);
-}, threeArgumentPooler = function(a1, a2, a3) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3), instance;
-    }
-    return new Klass(a1, a2, a3);
-}, fourArgumentPooler = function(a1, a2, a3, a4) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3, a4), instance;
-    }
-    return new Klass(a1, a2, a3, a4);
-}, standardReleaser = function(instance) {
-    var Klass = this;
-    invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
-    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
-}, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
-    var NewKlass = CopyConstructor;
-    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
-    NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
-    NewKlass;
-}, PooledClass = {
-    addPoolingTo: addPoolingTo,
-    oneArgumentPooler: oneArgumentPooler,
-    twoArgumentPooler: twoArgumentPooler,
-    threeArgumentPooler: threeArgumentPooler,
-    fourArgumentPooler: fourArgumentPooler
-}, PooledClass_1 = PooledClass, didWarnForAddedNewProperty = !1, isProxySupported = "function" == typeof Proxy, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
-    type: null,
-    target: null,
-    currentTarget: emptyFunction.thatReturnsNull,
-    eventPhase: null,
-    bubbles: null,
-    cancelable: null,
-    timeStamp: function(event) {
-        return event.timeStamp || Date.now();
-    },
-    defaultPrevented: null,
-    isTrusted: null
-};
-
-function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
-    delete this.nativeEvent, delete this.preventDefault, delete this.stopPropagation, 
-    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
-    var Interface = this.constructor.Interface;
-    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
-        delete this[propName];
-        var normalize = Interface[propName];
-        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
-    }
-    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
-    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
-    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
-}
-
-Object.assign(SyntheticEvent.prototype, {
-    preventDefault: function() {
-        this.defaultPrevented = !0;
-        var event = this.nativeEvent;
-        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
-        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
-    },
-    stopPropagation: function() {
-        var event = this.nativeEvent;
-        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
-        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
-    },
-    persist: function() {
-        this.isPersistent = emptyFunction.thatReturnsTrue;
-    },
-    isPersistent: emptyFunction.thatReturnsFalse,
-    destructor: function() {
-        var Interface = this.constructor.Interface;
-        for (var propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
-        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
-        Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null)), 
-        Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", emptyFunction)), 
-        Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", emptyFunction));
-    }
-}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
-    var Super = this, E = function() {};
-    E.prototype = Super.prototype;
-    var prototype = new E();
-    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
-    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
-    PooledClass_1.addPoolingTo(Class, PooledClass_1.fourArgumentPooler);
-}, isProxySupported && (SyntheticEvent = new Proxy(SyntheticEvent, {
-    construct: function(target, args) {
-        return this.apply(target, Object.create(target.prototype), args);
-    },
-    apply: function(constructor, that, args) {
-        return new Proxy(constructor.apply(that, args), {
-            set: function(target, prop, value) {
-                return "isPersistent" === prop || target.constructor.Interface.hasOwnProperty(prop) || -1 !== shouldBeReleasedProperties.indexOf(prop) || (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."), 
-                didWarnForAddedNewProperty = !0), target[prop] = value, !0;
-            }
-        });
-    }
-})), PooledClass_1.addPoolingTo(SyntheticEvent, PooledClass_1.fourArgumentPooler);
-
-var SyntheticEvent_1 = SyntheticEvent;
-
-function getPooledWarningPropertyDefinition(propName, getVal) {
-    var isFunction = "function" == typeof getVal;
-    return {
-        configurable: !0,
-        set: set,
-        get: get
-    };
-    function set(val) {
-        return warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op"), 
-        val;
-    }
-    function get() {
-        return warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null"), 
-        getVal;
-    }
-    function warn(action, result) {
-        warning(!1, "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);
-    }
-}
-
-var _extends = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
-
-for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
-
-for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
-allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
-
-var ReactNativeBridgeEventPlugin = {
-    eventTypes: _extends({}, customBubblingEventTypes, customDirectEventTypes),
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
-        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
-            if (!directDispatchConfig) return null;
-            EventPropagators_1.accumulateDirectDispatches(event);
-        }
-        return event;
-    }
-}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
-
-function runEventQueueInBatch(events) {
-    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
-}
-
-var ReactEventEmitterMixin = {
-    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
-    }
-}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
-    tagsStartAt: INITIAL_TAG_COUNT,
-    tagCount: INITIAL_TAG_COUNT,
-    allocateTag: function() {
-        for (;this.reactTagIsNativeTopRootID(ReactNativeTagHandles.tagCount); ) ReactNativeTagHandles.tagCount++;
-        var tag = ReactNativeTagHandles.tagCount;
-        return ReactNativeTagHandles.tagCount++, tag;
-    },
-    assertRootTag: function(tag) {
-        invariant(this.reactTagIsNativeTopRootID(tag), "Expect a native root tag, instead got %s", tag);
-    },
-    reactTagIsNativeTopRootID: function(reactTag) {
-        return reactTag % 10 == 1;
-    }
-}, ReactNativeTagHandles_1 = ReactNativeTagHandles, fiberHostComponent = null, ReactControlledComponentInjection = {
-    injectFiberControlledHostComponent: function(hostComponentImpl) {
-        fiberHostComponent = hostComponentImpl;
-    }
-}, restoreTarget = null, restoreQueue = null;
-
-function restoreStateOfTarget(target) {
-    var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
-    if (internalInstance) {
-        if ("number" == typeof internalInstance.tag) {
-            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "Fiber needs to be injected to handle a fiber target for controlled " + "events.");
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
-            return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
-        }
-        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component."), 
-        internalInstance.restoreControlledState();
-    }
-}
-
-var ReactControlledComponent = {
-    injection: ReactControlledComponentInjection,
-    enqueueStateRestore: function(target) {
-        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
-    },
-    restoreStateIfNeeded: function() {
-        if (restoreTarget) {
-            var target = restoreTarget, queuedTargets = restoreQueue;
-            if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
+    function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+        if (event && event.dispatchConfig.phasedRegistrationNames) {
+            var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
+            ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
         }
     }
-}, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
-    return fn(a, b, c, d, e);
-}, fiberBatchedUpdates = function(fn, bookkeeping) {
-    return fn(bookkeeping);
-};
-
-function performFiberBatchedUpdates(fn, bookkeeping) {
-    return fiberBatchedUpdates(fn, bookkeeping);
-}
-
-function batchedUpdates(fn, bookkeeping) {
-    return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
-}
-
-var isNestingBatched = !1;
-
-function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
-    if (isNestingBatched) return batchedUpdates(fn, bookkeeping);
-    isNestingBatched = !0;
-    try {
-        return batchedUpdates(fn, bookkeeping);
-    } finally {
-        isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
-    }
-}
-
-var ReactGenericBatchingInjection = {
-    injectStackBatchedUpdates: function(_batchedUpdates) {
-        stackBatchedUpdates = _batchedUpdates;
-    },
-    injectFiberBatchedUpdates: function(_batchedUpdates) {
-        fiberBatchedUpdates = _batchedUpdates;
-    }
-}, ReactGenericBatching = {
-    batchedUpdates: batchedUpdatesWithControlledComponents,
-    injection: ReactGenericBatchingInjection
-}, ReactGenericBatching_1 = ReactGenericBatching, _extends$1 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
-    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
-    return ret;
-}, removeTouchesAtIndices = function(touches, indices) {
-    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
-        var index = indices[i];
-        rippedOut.push(touches[index]), temp[index] = null;
-    }
-    for (var fillAt = 0, j = 0; j < temp.length; j++) {
-        var cur = temp[j];
-        null !== cur && (temp[fillAt++] = cur);
-    }
-    return temp.length = fillAt, rippedOut;
-}, ReactNativeEventEmitter = _extends$1({}, ReactEventEmitterMixin_1, {
-    registrationNames: EventPluginRegistry_1.registrationNameModules,
-    getListener: EventPluginHub_1.getListener,
-    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
-        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
-        ReactGenericBatching_1.batchedUpdates(function() {
-            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
-        });
-    },
-    receiveEvent: function(tag, topLevelType, nativeEventParam) {
-        var rootNodeID = tag;
-        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
-    },
-    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
-        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
-            var touch = changedTouches[jj];
-            touch.changedTouches = changedTouches, touch.touches = touches;
-            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
-            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt ? warning(!1, "A view is reporting that a touch occurred on tag zero.") : rootNodeID = target), 
-            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+    function accumulateDispatches(inst, ignoredDirection, event) {
+        if (inst && event && event.dispatchConfig.registrationName) {
+            var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+            listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+            event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
         }
     }
-}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
-    onChange: function(from, to, blockNativeResponder) {
-        if (null !== to) {
-            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
-            UIManager.setJSResponder(tag, blockNativeResponder);
-        } else UIManager.clearJSResponder();
+    function accumulateDirectDispatchesSingle(event) {
+        event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
     }
-}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
-    touchHistory: function(nativeEvent) {
-        return null;
+    function accumulateTwoPhaseDispatches(events) {
+        forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
     }
-};
-
-function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-}
-
-SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
-
-var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
-    touchBank: touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0
-};
-
-function timestampForTouch(touch) {
-    return touch.timeStamp || touch.timestamp;
-}
-
-function createTouchRecord(touch) {
-    return {
-        touchActive: !0,
-        startPageX: touch.pageX,
-        startPageY: touch.pageY,
-        startTimeStamp: timestampForTouch(touch),
-        currentPageX: touch.pageX,
-        currentPageY: touch.pageY,
-        currentTimeStamp: timestampForTouch(touch),
-        previousPageX: touch.pageX,
-        previousPageY: touch.pageY,
-        previousTimeStamp: timestampForTouch(touch)
-    };
-}
-
-function resetTouchRecord(touchRecord, touch) {
-    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
-    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
-    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
-    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
-    touchRecord.previousTimeStamp = timestampForTouch(touch);
-}
-
-function getTouchIdentifier(_ref) {
-    var identifier = _ref.identifier;
-    return invariant(null != identifier, "Touch object is missing identifier."), warning(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
-    identifier;
-}
-
-function recordTouchStart(touch) {
-    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
-    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
-    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-}
-
-function recordTouchMove(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function recordTouchEnd(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function printTouch(touch) {
-    return JSON.stringify({
-        identifier: touch.identifier,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        timestamp: timestampForTouch(touch)
-    });
-}
-
-function printTouchBank() {
-    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
-    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
-    printed;
-}
-
-var ResponderTouchHistoryStore = {
-    recordTouchTrack: function(topLevelType, nativeEvent) {
-        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) {
-            for (var i = 0; i < touchBank.length; i++) {
-                var touchTrackToCheck = touchBank[i];
-                if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
-                    touchHistory.indexOfSingleActiveTouch = i;
-                    break;
-                }
-            }
-            var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
-            warning(null != activeRecord && activeRecord.touchActive, "Cannot find single active touch.");
-        }
-    },
-    touchHistory: touchHistory
-}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
-
-function accumulate(current, next) {
-    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
-    var oldResponderInst = responderInst;
-    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
-}, eventTypes = {
-    startShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onStartShouldSetResponder",
-            captured: "onStartShouldSetResponderCapture"
-        }
-    },
-    scrollShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onScrollShouldSetResponder",
-            captured: "onScrollShouldSetResponderCapture"
-        }
-    },
-    selectionChangeShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onSelectionChangeShouldSetResponder",
-            captured: "onSelectionChangeShouldSetResponderCapture"
-        }
-    },
-    moveShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onMoveShouldSetResponder",
-            captured: "onMoveShouldSetResponderCapture"
-        }
-    },
-    responderStart: {
-        registrationName: "onResponderStart"
-    },
-    responderMove: {
-        registrationName: "onResponderMove"
-    },
-    responderEnd: {
-        registrationName: "onResponderEnd"
-    },
-    responderRelease: {
-        registrationName: "onResponderRelease"
-    },
-    responderTerminationRequest: {
-        registrationName: "onResponderTerminationRequest"
-    },
-    responderGrant: {
-        registrationName: "onResponderGrant"
-    },
-    responderReject: {
-        registrationName: "onResponderReject"
-    },
-    responderTerminate: {
-        registrationName: "onResponderTerminate"
+    function accumulateTwoPhaseDispatchesSkipTarget(events) {
+        forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
     }
-};
-
-function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
-    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
-    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
-    !wantsResponderInst || wantsResponderInst === responderInst) return null;
-    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
-    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
-    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
-    if (responderInst) {
-        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
-        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
-        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
-        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
-        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
-        shouldSwitch) {
-            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
-            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
-            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
-        } else {
-            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
-            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
-            extracted = accumulate_1(extracted, rejectEvent);
-        }
-    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
-    return extracted;
-}
-
-function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
-    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
-}
-
-function noResponderTouches(nativeEvent) {
-    var touches = nativeEvent.touches;
-    if (!touches || 0 === touches.length) return !0;
-    for (var i = 0; i < touches.length; i++) {
-        var activeTouch = touches[i], target = activeTouch.target;
-        if (null !== target && void 0 !== target && 0 !== target) {
-            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
-            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
-        }
+    function accumulateEnterLeaveDispatches(leave, enter, from, to) {
+        ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
     }
-    return !0;
-}
-
-var ResponderEventPlugin = {
-    _getResponder: function() {
-        return responderInst;
-    },
-    eventTypes: eventTypes,
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
-            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
-            null;
-            trackedTouchCount -= 1;
-        }
-        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
-        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
-        if (incrementalTouch) {
-            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
-            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
-            extracted = accumulate_1(extracted, gesture);
-        }
-        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
-        if (finalTouch) {
-            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
-            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
-            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
-        }
-        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
-        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
-        previousActiveTouches = numberActiveTouches, extracted;
-    },
-    GlobalResponderHandler: null,
-    GlobalInteractionHandler: null,
-    injection: {
-        injectGlobalResponderHandler: function(GlobalResponderHandler) {
-            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+    function accumulateDirectDispatches(events) {
+        forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
+    }
+    var EventPropagators = {
+        accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
+        accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
+        accumulateDirectDispatches: accumulateDirectDispatches,
+        accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
+    }, EventPropagators_1 = EventPropagators, didWarnForAddedNewProperty = !1, isProxySupported = "function" == typeof Proxy, EVENT_POOL_SIZE = 10, warning$8 = warning, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
+        type: null,
+        target: null,
+        currentTarget: emptyFunction.thatReturnsNull,
+        eventPhase: null,
+        bubbles: null,
+        cancelable: null,
+        timeStamp: function(event) {
+            return event.timeStamp || Date.now();
         },
-        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
-            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+        defaultPrevented: null,
+        isTrusted: null
+    };
+    function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+        delete this.nativeEvent, delete this.preventDefault, delete this.stopPropagation, 
+        this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
+        var Interface = this.constructor.Interface;
+        for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
+            delete this[propName];
+            var normalize = Interface[propName];
+            normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
+        }
+        var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
+        return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
+        this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
+    }
+    Object.assign(SyntheticEvent.prototype, {
+        preventDefault: function() {
+            this.defaultPrevented = !0;
+            var event = this.nativeEvent;
+            event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
+            this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
+        },
+        stopPropagation: function() {
+            var event = this.nativeEvent;
+            event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
+            this.isPropagationStopped = emptyFunction.thatReturnsTrue);
+        },
+        persist: function() {
+            this.isPersistent = emptyFunction.thatReturnsTrue;
+        },
+        isPersistent: emptyFunction.thatReturnsFalse,
+        destructor: function() {
+            var Interface = this.constructor.Interface;
+            for (var propName in Interface) Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
+            for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
+            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null)), 
+            Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", emptyFunction)), 
+            Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", emptyFunction));
+        }
+    }), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
+        var Super = this, E = function() {};
+        E.prototype = Super.prototype;
+        var prototype = new E();
+        Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
+        Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
+        addEventPoolingTo(Class);
+    }, isProxySupported && (SyntheticEvent = new Proxy(SyntheticEvent, {
+        construct: function(target, args) {
+            return this.apply(target, Object.create(target.prototype), args);
+        },
+        apply: function(constructor, that, args) {
+            return new Proxy(constructor.apply(that, args), {
+                set: function(target, prop, value) {
+                    return "isPersistent" === prop || target.constructor.Interface.hasOwnProperty(prop) || -1 !== shouldBeReleasedProperties.indexOf(prop) || (warning$8(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."), 
+                    didWarnForAddedNewProperty = !0), target[prop] = value, !0;
+                }
+            });
+        }
+    })), addEventPoolingTo(SyntheticEvent);
+    var SyntheticEvent_1 = SyntheticEvent;
+    function getPooledWarningPropertyDefinition(propName, getVal) {
+        var isFunction = "function" == typeof getVal;
+        return {
+            configurable: !0,
+            set: set,
+            get: get
+        };
+        function set(val) {
+            return warn(isFunction ? "setting the method" : "setting the property", "This is effectively a no-op"), 
+            val;
+        }
+        function get() {
+            return warn(isFunction ? "accessing the method" : "accessing the property", isFunction ? "This is a no-op function" : "This is set to null"), 
+            getVal;
+        }
+        function warn(action, result) {
+            warning$8(!1, "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);
         }
     }
-}, ResponderEventPlugin_1 = ResponderEventPlugin;
-
-function inject() {
+    function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+        var EventConstructor = this;
+        if (EventConstructor.eventPool.length) {
+            var instance = EventConstructor.eventPool.pop();
+            return EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst), 
+            instance;
+        }
+        return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+    }
+    function releasePooledEvent(event) {
+        var EventConstructor = this;
+        invariant(event instanceof EventConstructor, "Trying to release an event instance  into a pool of a different type."), 
+        event.destructor(), EventConstructor.eventPool.length < EVENT_POOL_SIZE && EventConstructor.eventPool.push(event);
+    }
+    function addEventPoolingTo(EventConstructor) {
+        EventConstructor.eventPool = [], EventConstructor.getPooled = getPooledEvent, EventConstructor.release = releasePooledEvent;
+    }
+    var customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
+    for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
+    for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
+    allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
+    var ReactNativeBridgeEventPlugin = {
+        eventTypes: Object.assign({}, customBubblingEventTypes, customDirectEventTypes),
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+            if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
+                if (!directDispatchConfig) return null;
+                EventPropagators_1.accumulateDirectDispatches(event);
+            }
+            return event;
+        }
+    }, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
+    function runEventQueueInBatch(events) {
+        EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
+    }
+    var ReactEventEmitterMixin = {
+        handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
+        }
+    }, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, fiberHostComponent = null, ReactControlledComponentInjection = {
+        injectFiberControlledHostComponent: function(hostComponentImpl) {
+            fiberHostComponent = hostComponentImpl;
+        }
+    }, restoreTarget = null, restoreQueue = null;
+    function restoreStateOfTarget(target) {
+        var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
+        if (internalInstance) {
+            if ("number" == typeof internalInstance.tag) {
+                invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "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.");
+                var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
+                return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+            }
+            invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component. " + "This error is likely caused by a bug in React. Please file an issue."), 
+            internalInstance.restoreControlledState();
+        }
+    }
+    var ReactControlledComponent = {
+        injection: ReactControlledComponentInjection,
+        enqueueStateRestore: function(target) {
+            restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
+        },
+        restoreStateIfNeeded: function() {
+            if (restoreTarget) {
+                var target = restoreTarget, queuedTargets = restoreQueue;
+                if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
+            }
+        }
+    }, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
+        return fn(a, b, c, d, e);
+    }, fiberBatchedUpdates = function(fn, bookkeeping) {
+        return fn(bookkeeping);
+    };
+    function performFiberBatchedUpdates(fn, bookkeeping) {
+        return fiberBatchedUpdates(fn, bookkeeping);
+    }
+    function batchedUpdates$1(fn, bookkeeping) {
+        return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
+    }
+    var isNestingBatched = !1;
+    function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
+        if (isNestingBatched) return batchedUpdates$1(fn, bookkeeping);
+        isNestingBatched = !0;
+        try {
+            return batchedUpdates$1(fn, bookkeeping);
+        } finally {
+            isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
+        }
+    }
+    var ReactGenericBatchingInjection = {
+        injectStackBatchedUpdates: function(_batchedUpdates) {
+            stackBatchedUpdates = _batchedUpdates;
+        },
+        injectFiberBatchedUpdates: function(_batchedUpdates) {
+            fiberBatchedUpdates = _batchedUpdates;
+        }
+    }, ReactGenericBatching = {
+        batchedUpdates: batchedUpdatesWithControlledComponents,
+        injection: ReactGenericBatchingInjection
+    }, ReactGenericBatching_1 = ReactGenericBatching, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
+        for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
+        return ret;
+    }, removeTouchesAtIndices = function(touches, indices) {
+        for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
+            var index = indices[i];
+            rippedOut.push(touches[index]), temp[index] = null;
+        }
+        for (var fillAt = 0, j = 0; j < temp.length; j++) {
+            var cur = temp[j];
+            null !== cur && (temp[fillAt++] = cur);
+        }
+        return temp.length = fillAt, rippedOut;
+    }, ReactNativeEventEmitter = Object.assign({}, ReactEventEmitterMixin_1, {
+        registrationNames: EventPluginRegistry_1.registrationNameModules,
+        getListener: EventPluginHub_1.getListener,
+        _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
+            var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
+            ReactGenericBatching_1.batchedUpdates(function() {
+                ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
+            });
+        },
+        receiveEvent: function(tag, topLevelType, nativeEventParam) {
+            var rootNodeID = tag;
+            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+        },
+        receiveTouches: function(eventTopLevelType, touches, changedIndices) {
+            for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
+                var touch = changedTouches[jj];
+                touch.changedTouches = changedTouches, touch.touches = touches;
+                var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
+                null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt ? warning(!1, "A view is reporting that a touch occurred on tag zero.") : rootNodeID = target), 
+                ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+            }
+        }
+    }), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
+        onChange: function(from, to, blockNativeResponder) {
+            if (null !== to) {
+                var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
+                UIManager.setJSResponder(tag, blockNativeResponder);
+            } else UIManager.clearJSResponder();
+        }
+    }, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
+        touchHistory: function(nativeEvent) {
+            return null;
+        }
+    };
+    function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+        return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+    }
+    SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
+    var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, warning$9 = warning, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
+        touchBank: touchBank,
+        numberActiveTouches: 0,
+        indexOfSingleActiveTouch: -1,
+        mostRecentTimeStamp: 0
+    };
+    function timestampForTouch(touch) {
+        return touch.timeStamp || touch.timestamp;
+    }
+    function createTouchRecord(touch) {
+        return {
+            touchActive: !0,
+            startPageX: touch.pageX,
+            startPageY: touch.pageY,
+            startTimeStamp: timestampForTouch(touch),
+            currentPageX: touch.pageX,
+            currentPageY: touch.pageY,
+            currentTimeStamp: timestampForTouch(touch),
+            previousPageX: touch.pageX,
+            previousPageY: touch.pageY,
+            previousTimeStamp: timestampForTouch(touch)
+        };
+    }
+    function resetTouchRecord(touchRecord, touch) {
+        touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
+        touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
+        touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
+        touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
+        touchRecord.previousTimeStamp = timestampForTouch(touch);
+    }
+    function getTouchIdentifier(_ref) {
+        var identifier = _ref.identifier;
+        return invariant(null != identifier, "Touch object is missing identifier."), warning$9(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
+        identifier;
+    }
+    function recordTouchStart(touch) {
+        var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
+        touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
+        touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+    }
+    function recordTouchMove(touch) {
+        var touchRecord = touchBank[getTouchIdentifier(touch)];
+        touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
+        touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+        touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+        touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function recordTouchEnd(touch) {
+        var touchRecord = touchBank[getTouchIdentifier(touch)];
+        touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
+        touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+        touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+        touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+    }
+    function printTouch(touch) {
+        return JSON.stringify({
+            identifier: touch.identifier,
+            pageX: touch.pageX,
+            pageY: touch.pageY,
+            timestamp: timestampForTouch(touch)
+        });
+    }
+    function printTouchBank() {
+        var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+        return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
+        printed;
+    }
+    var ResponderTouchHistoryStore = {
+        recordTouchTrack: function(topLevelType, nativeEvent) {
+            if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
+            touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
+            touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) {
+                for (var i = 0; i < touchBank.length; i++) {
+                    var touchTrackToCheck = touchBank[i];
+                    if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
+                        touchHistory.indexOfSingleActiveTouch = i;
+                        break;
+                    }
+                }
+                var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+                warning$9(null != activeRecord && activeRecord.touchActive, "Cannot find single active touch.");
+            }
+        },
+        touchHistory: touchHistory
+    }, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
+    function accumulate(current, next) {
+        return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
+        null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+    }
+    var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
+        var oldResponderInst = responderInst;
+        responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+    }, eventTypes = {
+        startShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onStartShouldSetResponder",
+                captured: "onStartShouldSetResponderCapture"
+            }
+        },
+        scrollShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onScrollShouldSetResponder",
+                captured: "onScrollShouldSetResponderCapture"
+            }
+        },
+        selectionChangeShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onSelectionChangeShouldSetResponder",
+                captured: "onSelectionChangeShouldSetResponderCapture"
+            }
+        },
+        moveShouldSetResponder: {
+            phasedRegistrationNames: {
+                bubbled: "onMoveShouldSetResponder",
+                captured: "onMoveShouldSetResponderCapture"
+            }
+        },
+        responderStart: {
+            registrationName: "onResponderStart"
+        },
+        responderMove: {
+            registrationName: "onResponderMove"
+        },
+        responderEnd: {
+            registrationName: "onResponderEnd"
+        },
+        responderRelease: {
+            registrationName: "onResponderRelease"
+        },
+        responderTerminationRequest: {
+            registrationName: "onResponderTerminationRequest"
+        },
+        responderGrant: {
+            registrationName: "onResponderGrant"
+        },
+        responderReject: {
+            registrationName: "onResponderReject"
+        },
+        responderTerminate: {
+            registrationName: "onResponderTerminate"
+        }
+    };
+    function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
+        shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
+        var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
+        if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
+        !wantsResponderInst || wantsResponderInst === responderInst) return null;
+        var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
+        grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
+        var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
+        if (responderInst) {
+            var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
+            terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
+            EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
+            var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
+            if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
+            shouldSwitch) {
+                var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+                terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
+                extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
+            } else {
+                var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
+                rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
+                extracted = accumulate_1(extracted, rejectEvent);
+            }
+        } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
+        return extracted;
+    }
+    function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
+        return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
+    }
+    function noResponderTouches(nativeEvent) {
+        var touches = nativeEvent.touches;
+        if (!touches || 0 === touches.length) return !0;
+        for (var i = 0; i < touches.length; i++) {
+            var activeTouch = touches[i], target = activeTouch.target;
+            if (null !== target && void 0 !== target && 0 !== target) {
+                var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
+                if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
+            }
+        }
+        return !0;
+    }
+    var ResponderEventPlugin = {
+        _getResponder: function() {
+            return responderInst;
+        },
+        eventTypes: eventTypes,
+        extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+            if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
+                if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
+                null;
+                trackedTouchCount -= 1;
+            }
+            ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
+            var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
+            if (incrementalTouch) {
+                var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
+                gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
+                extracted = accumulate_1(extracted, gesture);
+            }
+            var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
+            if (finalTouch) {
+                var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
+                finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
+                extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
+            }
+            var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
+            return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
+            previousActiveTouches = numberActiveTouches, extracted;
+        },
+        GlobalResponderHandler: null,
+        GlobalInteractionHandler: null,
+        injection: {
+            injectGlobalResponderHandler: function(GlobalResponderHandler) {
+                ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+            },
+            injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
+                ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+            }
+        }
+    }, ResponderEventPlugin_1 = ResponderEventPlugin;
     RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
     EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
     EventPluginHub_1.injection.injectEventPluginsByName({
         ResponderEventPlugin: ResponderEventPlugin_1,
         ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
     });
-}
-
-var ReactNativeInjection = {
-    inject: inject
-}, ReactInvalidSetStateWarningHook = {}, processingChildContext = !1, warnInvalidSetState = function() {
-    warning(!processingChildContext, "setState(...): Cannot call setState() inside getChildContext()");
-};
-
-ReactInvalidSetStateWarningHook = {
-    onBeginProcessingChildContext: function() {
-        processingChildContext = !0;
-    },
-    onEndProcessingChildContext: function() {
-        processingChildContext = !1;
-    },
-    onSetState: function() {
-        warnInvalidSetState();
-    }
-};
-
-var ReactInvalidSetStateWarningHook_1 = ReactInvalidSetStateWarningHook, ReactHostOperationHistoryHook = null, history = [];
-
-ReactHostOperationHistoryHook = {
-    onHostOperation: function(operation) {
-        history.push(operation);
-    },
-    clearHistory: function() {
-        ReactHostOperationHistoryHook._preventClearing || (history = []);
-    },
-    getHistory: function() {
-        return history;
-    }
-};
-
-var ReactHostOperationHistoryHook_1 = ReactHostOperationHistoryHook, ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, ReactGlobalSharedState = {
-    ReactCurrentOwner: ReactInternals.ReactCurrentOwner
-};
-
-Object.assign(ReactGlobalSharedState, {
-    ReactComponentTreeHook: ReactInternals.ReactComponentTreeHook,
-    ReactDebugCurrentFrame: ReactInternals.ReactDebugCurrentFrame
-});
-
-var ReactGlobalSharedState_1 = ReactGlobalSharedState, ReactComponentTreeHook = ReactGlobalSharedState_1.ReactComponentTreeHook, ReactDebugTool$1 = null, hooks = [], didHookThrowForEvent = {}, callHook = function(event, fn, context, arg1, arg2, arg3, arg4, arg5) {
-    try {
-        fn.call(context, arg1, arg2, arg3, arg4, arg5);
-    } catch (e) {
-        warning(didHookThrowForEvent[event], "Exception thrown by hook while handling %s: %s", event, e + "\n" + e.stack), 
-        didHookThrowForEvent[event] = !0;
-    }
-}, emitEvent = function(event, arg1, arg2, arg3, arg4, arg5) {
-    for (var i = 0; i < hooks.length; i++) {
-        var hook = hooks[i], fn = hook[event];
-        fn && callHook(event, fn, hook, arg1, arg2, arg3, arg4, arg5);
-    }
-}, isProfiling = !1, flushHistory = [], lifeCycleTimerStack = [], currentFlushNesting = 0, currentFlushMeasurements = [], currentFlushStartTime = 0, currentTimerDebugID = null, currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerType = null, lifeCycleTimerHasWarned = !1, clearHistory = function() {
-    ReactComponentTreeHook.purgeUnmountedComponents(), ReactHostOperationHistoryHook_1.clearHistory();
-}, getTreeSnapshot = function(registeredIDs) {
-    return registeredIDs.reduce(function(tree, id) {
-        var ownerID = ReactComponentTreeHook.getOwnerID(id), parentID = ReactComponentTreeHook.getParentID(id);
-        return tree[id] = {
-            displayName: ReactComponentTreeHook.getDisplayName(id),
-            text: ReactComponentTreeHook.getText(id),
-            updateCount: ReactComponentTreeHook.getUpdateCount(id),
-            childIDs: ReactComponentTreeHook.getChildIDs(id),
-            ownerID: ownerID || parentID && ReactComponentTreeHook.getOwnerID(parentID) || 0,
-            parentID: parentID
-        }, tree;
-    }, {});
-}, resetMeasurements = function() {
-    var previousStartTime = currentFlushStartTime, previousMeasurements = currentFlushMeasurements, previousOperations = ReactHostOperationHistoryHook_1.getHistory();
-    if (0 === currentFlushNesting) return currentFlushStartTime = 0, currentFlushMeasurements = [], 
-    void clearHistory();
-    if (previousMeasurements.length || previousOperations.length) {
-        var registeredIDs = ReactComponentTreeHook.getRegisteredIDs();
-        flushHistory.push({
-            duration: performanceNow() - previousStartTime,
-            measurements: previousMeasurements || [],
-            operations: previousOperations || [],
-            treeSnapshot: getTreeSnapshot(registeredIDs)
-        });
-    }
-    clearHistory(), currentFlushStartTime = performanceNow(), currentFlushMeasurements = [];
-}, checkDebugID = function(debugID) {
-    arguments.length > 1 && void 0 !== arguments[1] && arguments[1] && 0 === debugID || debugID || warning(!1, "ReactDebugTool: debugID may not be empty.");
-}, beginLifeCycleTimer = function(debugID, timerType) {
-    0 !== currentFlushNesting && (currentTimerType && !lifeCycleTimerHasWarned && (warning(!1, "There is an internal error in the React performance measurement code." + "\n\nDid not expect %s timer to start while %s timer is still in " + "progress for %s instance.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
-    lifeCycleTimerHasWarned = !0), currentTimerStartTime = performanceNow(), currentTimerNestedFlushDuration = 0, 
-    currentTimerDebugID = debugID, currentTimerType = timerType);
-}, endLifeCycleTimer = function(debugID, timerType) {
-    0 !== currentFlushNesting && (currentTimerType === timerType || lifeCycleTimerHasWarned || (warning(!1, "There is an internal error in the React performance measurement code. " + "We did not expect %s timer to stop while %s timer is still in " + "progress for %s instance. Please report this as a bug in React.", timerType, currentTimerType || "no", debugID === currentTimerDebugID ? "the same" : "another"), 
-    lifeCycleTimerHasWarned = !0), isProfiling && currentFlushMeasurements.push({
-        timerType: timerType,
-        instanceID: debugID,
-        duration: performanceNow() - currentTimerStartTime - currentTimerNestedFlushDuration
-    }), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, currentTimerDebugID = null, 
-    currentTimerType = null);
-}, pauseCurrentLifeCycleTimer = function() {
-    var currentTimer = {
-        startTime: currentTimerStartTime,
-        nestedFlushStartTime: performanceNow(),
-        debugID: currentTimerDebugID,
-        timerType: currentTimerType
-    };
-    lifeCycleTimerStack.push(currentTimer), currentTimerStartTime = 0, currentTimerNestedFlushDuration = 0, 
-    currentTimerDebugID = null, currentTimerType = null;
-}, resumeCurrentLifeCycleTimer = function() {
-    var _lifeCycleTimerStack$ = lifeCycleTimerStack.pop(), startTime = _lifeCycleTimerStack$.startTime, nestedFlushStartTime = _lifeCycleTimerStack$.nestedFlushStartTime, debugID = _lifeCycleTimerStack$.debugID, timerType = _lifeCycleTimerStack$.timerType, nestedFlushDuration = performanceNow() - nestedFlushStartTime;
-    currentTimerStartTime = startTime, currentTimerNestedFlushDuration += nestedFlushDuration, 
-    currentTimerDebugID = debugID, currentTimerType = timerType;
-}, lastMarkTimeStamp = 0, canUsePerformanceMeasure = "undefined" != typeof performance && "function" == typeof performance.mark && "function" == typeof performance.clearMarks && "function" == typeof performance.measure && "function" == typeof performance.clearMeasures, shouldMark = function(debugID) {
-    if (!isProfiling || !canUsePerformanceMeasure) return !1;
-    var element = ReactComponentTreeHook.getElement(debugID);
-    return null != element && "object" == typeof element && !("string" == typeof element.type);
-}, markBegin = function(debugID, markType) {
-    if (shouldMark(debugID)) {
-        var markName = debugID + "::" + markType;
-        lastMarkTimeStamp = performanceNow(), performance.mark(markName);
-    }
-}, markEnd = function(debugID, markType) {
-    if (shouldMark(debugID)) {
-        var markName = debugID + "::" + markType, displayName = ReactComponentTreeHook.getDisplayName(debugID) || "Unknown";
-        if (performanceNow() - lastMarkTimeStamp > .1) {
-            var measurementName = displayName + " [" + markType + "]";
-            performance.measure(measurementName, markName);
+    var RESET_BATCHED_UPDATES = {
+        initialize: emptyFunction,
+        close: function() {
+            ReactDefaultBatchingStrategy.isBatchingUpdates = !1;
         }
-        performance.clearMarks(markName), measurementName && performance.clearMeasures(measurementName);
+    }, FLUSH_BATCHED_UPDATES = {
+        initialize: emptyFunction,
+        close: ReactUpdates_1.flushBatchedUpdates.bind(ReactUpdates_1)
+    }, TRANSACTION_WRAPPERS$1 = [ FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES ];
+    function ReactDefaultBatchingStrategyTransaction() {
+        this.reinitializeTransaction();
     }
-};
-
-ReactDebugTool$1 = {
-    addHook: function(hook) {
-        hooks.push(hook);
-    },
-    removeHook: function(hook) {
-        for (var i = 0; i < hooks.length; i++) hooks[i] === hook && (hooks.splice(i, 1), 
-        i--);
-    },
-    isProfiling: function() {
-        return isProfiling;
-    },
-    beginProfiling: function() {
-        isProfiling || (isProfiling = !0, flushHistory.length = 0, resetMeasurements(), 
-        ReactDebugTool$1.addHook(ReactHostOperationHistoryHook_1));
-    },
-    endProfiling: function() {
-        isProfiling && (isProfiling = !1, resetMeasurements(), ReactDebugTool$1.removeHook(ReactHostOperationHistoryHook_1));
-    },
-    getFlushHistory: function() {
-        return flushHistory;
-    },
-    onBeginFlush: function() {
-        currentFlushNesting++, resetMeasurements(), pauseCurrentLifeCycleTimer(), emitEvent("onBeginFlush");
-    },
-    onEndFlush: function() {
-        resetMeasurements(), currentFlushNesting--, resumeCurrentLifeCycleTimer(), emitEvent("onEndFlush");
-    },
-    onBeginLifeCycleTimer: function(debugID, timerType) {
-        checkDebugID(debugID), emitEvent("onBeginLifeCycleTimer", debugID, timerType), markBegin(debugID, timerType), 
-        beginLifeCycleTimer(debugID, timerType);
-    },
-    onEndLifeCycleTimer: function(debugID, timerType) {
-        checkDebugID(debugID), endLifeCycleTimer(debugID, timerType), markEnd(debugID, timerType), 
-        emitEvent("onEndLifeCycleTimer", debugID, timerType);
-    },
-    onBeginProcessingChildContext: function() {
-        emitEvent("onBeginProcessingChildContext");
-    },
-    onEndProcessingChildContext: function() {
-        emitEvent("onEndProcessingChildContext");
-    },
-    onHostOperation: function(operation) {
-        checkDebugID(operation.instanceID), emitEvent("onHostOperation", operation);
-    },
-    onSetState: function() {
-        emitEvent("onSetState");
-    },
-    onSetChildren: function(debugID, childDebugIDs) {
-        checkDebugID(debugID), childDebugIDs.forEach(checkDebugID), emitEvent("onSetChildren", debugID, childDebugIDs);
-    },
-    onBeforeMountComponent: function(debugID, element, parentDebugID) {
-        checkDebugID(debugID), checkDebugID(parentDebugID, !0), emitEvent("onBeforeMountComponent", debugID, element, parentDebugID), 
-        markBegin(debugID, "mount");
-    },
-    onMountComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "mount"), emitEvent("onMountComponent", debugID);
-    },
-    onBeforeUpdateComponent: function(debugID, element) {
-        checkDebugID(debugID), emitEvent("onBeforeUpdateComponent", debugID, element), markBegin(debugID, "update");
-    },
-    onUpdateComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "update"), emitEvent("onUpdateComponent", debugID);
-    },
-    onBeforeUnmountComponent: function(debugID) {
-        checkDebugID(debugID), emitEvent("onBeforeUnmountComponent", debugID), markBegin(debugID, "unmount");
-    },
-    onUnmountComponent: function(debugID) {
-        checkDebugID(debugID), markEnd(debugID, "unmount"), emitEvent("onUnmountComponent", debugID);
-    },
-    onTestEvent: function() {
-        emitEvent("onTestEvent");
-    }
-}, ReactDebugTool$1.addHook(ReactInvalidSetStateWarningHook_1), ReactDebugTool$1.addHook(ReactComponentTreeHook);
-
-var url = ExecutionEnvironment.canUseDOM && window.location.href || "";
-
-/[?&]react_perf\b/.test(url) && ReactDebugTool$1.beginProfiling();
-
-var ReactDebugTool_1 = ReactDebugTool$1, debugTool = null, ReactDebugTool = ReactDebugTool_1;
-
-debugTool = ReactDebugTool;
-
-var ReactInstrumentation = {
-    debugTool: debugTool
-};
-
-function ReactNativeContainerInfo(tag) {
-    return {
-        _tag: tag
-    };
-}
-
-var ReactNativeContainerInfo_1 = ReactNativeContainerInfo, ClassComponent = ReactTypeOfWork.ClassComponent;
-
-function isValidOwner(object) {
-    return !(!object || "function" != typeof object.attachRef || "function" != typeof object.detachRef);
-}
-
-var ReactOwner = {
-    addComponentAsRefTo: function(component, ref, owner) {
-        if (owner && owner.tag === ClassComponent) {
-            var inst = owner.stateNode;
-            (inst.refs === emptyObject ? inst.refs = {} : inst.refs)[ref] = component.getPublicInstance();
-        } else invariant(isValidOwner(owner), "addComponentAsRefTo(...): Only a ReactOwner can have refs. You might " + "be adding a ref to a component that was not created inside a component's " + "`render` method, or you have multiple copies of React loaded " + "(details: https://fb.me/react-refs-must-have-owner)."), 
-        owner.attachRef(ref, component);
-    },
-    removeComponentAsRefFrom: function(component, ref, owner) {
-        if (owner && owner.tag === ClassComponent) {
-            var inst = owner.stateNode;
-            inst && inst.refs[ref] === component.getPublicInstance() && delete inst.refs[ref];
-        } else {
-            invariant(isValidOwner(owner), "removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might " + "be removing a ref to a component that was not created inside a component's " + "`render` method, or you have multiple copies of React loaded " + "(details: https://fb.me/react-refs-must-have-owner).");
-            var ownerPublicInstance = owner.getPublicInstance();
-            ownerPublicInstance && ownerPublicInstance.refs[ref] === component.getPublicInstance() && owner.detachRef(ref);
+    Object.assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {
+        getTransactionWrappers: function() {
+            return TRANSACTION_WRAPPERS$1;
         }
-    }
-}, ReactOwner_1 = ReactOwner, ReactCompositeComponentTypes$1 = {
-    ImpureClass: 0,
-    PureClass: 1,
-    StatelessFunctional: 2
-}, ReactRef = {}, ReactCompositeComponentTypes = ReactCompositeComponentTypes$1, _require$1 = ReactGlobalSharedState_1, ReactComponentTreeHook$1 = _require$1.ReactComponentTreeHook, warning$2 = warning, warnedAboutStatelessRefs = {};
-
-function attachRef(ref, component, owner) {
-    if (component._compositeType === ReactCompositeComponentTypes.StatelessFunctional) {
-        var info = "", ownerName = void 0;
-        owner && ("function" == typeof owner.getName && (ownerName = owner.getName()), ownerName && (info += "\n\nCheck the render method of `" + ownerName + "`."));
-        var warningKey = ownerName || component._debugID, element = component._currentElement;
-        element && element._source && (warningKey = element._source.fileName + ":" + element._source.lineNumber), 
-        warnedAboutStatelessRefs[warningKey] || (warnedAboutStatelessRefs[warningKey] = !0, 
-        warning$2(!1, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactComponentTreeHook$1.getStackAddendumByID(component._debugID)));
-    }
-    "function" == typeof ref ? ref(component.getPublicInstance()) : ReactOwner_1.addComponentAsRefTo(component, ref, owner);
-}
-
-function detachRef(ref, component, owner) {
-    "function" == typeof ref ? ref(null) : ReactOwner_1.removeComponentAsRefFrom(component, ref, owner);
-}
-
-ReactRef.attachRefs = function(instance, element) {
-    if (null !== element && "object" == typeof element) {
-        var ref = element.ref;
-        null != ref && attachRef(ref, instance, element._owner);
-    }
-}, ReactRef.shouldUpdateRefs = function(prevElement, nextElement) {
-    var prevRef = null, prevOwner = null;
-    null !== prevElement && "object" == typeof prevElement && (prevRef = prevElement.ref, 
-    prevOwner = prevElement._owner);
-    var nextRef = null, nextOwner = null;
-    return null !== nextElement && "object" == typeof nextElement && (nextRef = nextElement.ref, 
-    nextOwner = nextElement._owner), prevRef !== nextRef || "string" == typeof nextRef && nextOwner !== prevOwner;
-}, ReactRef.detachRefs = function(instance, element) {
-    if (null !== element && "object" == typeof element) {
-        var ref = element.ref;
-        null != ref && detachRef(ref, instance, element._owner);
-    }
-};
-
-var ReactRef_1 = ReactRef;
-
-function attachRefs() {
-    ReactRef_1.attachRefs(this, this._currentElement);
-}
-
-var ReactReconciler = {
-    mountComponent: function(internalInstance, transaction, hostParent, hostContainerInfo, context, parentDebugID) {
-        0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeMountComponent(internalInstance._debugID, internalInstance._currentElement, parentDebugID);
-        var markup = internalInstance.mountComponent(transaction, hostParent, hostContainerInfo, context, parentDebugID);
-        return internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), 
-        0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onMountComponent(internalInstance._debugID), 
-        markup;
-    },
-    getHostNode: function(internalInstance) {
-        return internalInstance.getHostNode();
-    },
-    unmountComponent: function(internalInstance, safely, skipLifecycle) {
-        0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUnmountComponent(internalInstance._debugID), 
-        ReactRef_1.detachRefs(internalInstance, internalInstance._currentElement), internalInstance.unmountComponent(safely, skipLifecycle), 
-        0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUnmountComponent(internalInstance._debugID);
-    },
-    receiveComponent: function(internalInstance, nextElement, transaction, context) {
-        var prevElement = internalInstance._currentElement;
-        if (nextElement !== prevElement || context !== internalInstance._context) {
-            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, nextElement);
-            var refsChanged = ReactRef_1.shouldUpdateRefs(prevElement, nextElement);
-            refsChanged && ReactRef_1.detachRefs(internalInstance, prevElement), internalInstance.receiveComponent(nextElement, transaction, context), 
-            refsChanged && internalInstance._currentElement && null != internalInstance._currentElement.ref && transaction.getReactMountReady().enqueue(attachRefs, internalInstance), 
-            0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
+    });
+    var transaction = new ReactDefaultBatchingStrategyTransaction(), ReactDefaultBatchingStrategy = {
+        isBatchingUpdates: !1,
+        batchedUpdates: function(callback, a, b, c, d, e) {
+            var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
+            return ReactDefaultBatchingStrategy.isBatchingUpdates = !0, alreadyBatchingUpdates ? callback(a, b, c, d, e) : transaction.perform(callback, null, a, b, c, d, e);
         }
-    },
-    performUpdateIfNecessary: function(internalInstance, transaction, updateBatchNumber) {
-        if (internalInstance._updateBatchNumber !== updateBatchNumber) return void warning(null == internalInstance._updateBatchNumber || internalInstance._updateBatchNumber === updateBatchNumber + 1, "performUpdateIfNecessary: Unexpected batch number (current %s, " + "pending %s)", updateBatchNumber, internalInstance._updateBatchNumber);
-        0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onBeforeUpdateComponent(internalInstance._debugID, internalInstance._currentElement), 
-        internalInstance.performUpdateIfNecessary(transaction), 0 !== internalInstance._debugID && ReactInstrumentation.debugTool.onUpdateComponent(internalInstance._debugID);
-    }
-}, ReactReconciler_1 = ReactReconciler, ReactInstanceMap = {
-    remove: function(key) {
-        key._reactInternalInstance = void 0;
-    },
-    get: function(key) {
-        return key._reactInternalInstance;
-    },
-    has: function(key) {
-        return void 0 !== key._reactInternalInstance;
-    },
-    set: function(key, value) {
-        key._reactInternalInstance = value;
-    }
-}, ReactInstanceMap_1 = ReactInstanceMap, OBSERVED_ERROR = {}, TransactionImpl = {
-    reinitializeTransaction: function() {
-        this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], 
-        this._isInTransaction = !1;
-    },
-    _isInTransaction: !1,
-    getTransactionWrappers: null,
-    isInTransaction: function() {
-        return !!this._isInTransaction;
-    },
-    perform: function(method, scope, a, b, c, d, e, f) {
-        invariant(!this.isInTransaction(), "Transaction.perform(...): Cannot initialize a transaction when there " + "is already an outstanding transaction.");
-        var errorThrown, ret;
-        try {
-            this._isInTransaction = !0, errorThrown = !0, this.initializeAll(0), ret = method.call(scope, a, b, c, d, e, f), 
-            errorThrown = !1;
-        } finally {
-            try {
-                if (errorThrown) try {
-                    this.closeAll(0);
-                } catch (err) {} else this.closeAll(0);
-            } finally {
-                this._isInTransaction = !1;
-            }
-        }
-        return ret;
-    },
-    initializeAll: function(startIndex) {
-        for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) {
-            var wrapper = transactionWrappers[i];
-            try {
-                this.wrapperInitData[i] = OBSERVED_ERROR, this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null;
-            } finally {
-                if (this.wrapperInitData[i] === OBSERVED_ERROR) try {
-                    this.initializeAll(i + 1);
-                } catch (err) {}
-            }
-        }
-    },
-    closeAll: function(startIndex) {
-        invariant(this.isInTransaction(), "Transaction.closeAll(): Cannot close transaction when none are open.");
-        for (var transactionWrappers = this.transactionWrappers, i = startIndex; i < transactionWrappers.length; i++) {
-            var errorThrown, wrapper = transactionWrappers[i], initData = this.wrapperInitData[i];
-            try {
-                errorThrown = !0, initData !== OBSERVED_ERROR && wrapper.close && wrapper.close.call(this, initData), 
-                errorThrown = !1;
-            } finally {
-                if (errorThrown) try {
-                    this.closeAll(i + 1);
-                } catch (e) {}
-            }
-        }
-        this.wrapperInitData.length = 0;
-    }
-}, Transaction = TransactionImpl, dirtyComponents = [], updateBatchNumber = 0, batchingStrategy = null;
-
-function ensureInjected() {
-    invariant(ReactUpdates.ReactReconcileTransaction && batchingStrategy, "ReactUpdates: must inject a reconcile transaction class and batching " + "strategy");
-}
-
-var NESTED_UPDATES = {
-    initialize: function() {
-        this.dirtyComponentsLength = dirtyComponents.length;
-    },
-    close: function() {
-        this.dirtyComponentsLength !== dirtyComponents.length ? (dirtyComponents.splice(0, this.dirtyComponentsLength), 
-        flushBatchedUpdates()) : dirtyComponents.length = 0;
-    }
-}, TRANSACTION_WRAPPERS = [ NESTED_UPDATES ];
-
-function ReactUpdatesFlushTransaction() {
-    this.reinitializeTransaction(), this.dirtyComponentsLength = null, this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled(!0);
-}
-
-Object.assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
-    getTransactionWrappers: function() {
-        return TRANSACTION_WRAPPERS;
-    },
-    destructor: function() {
-        this.dirtyComponentsLength = null, ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction), 
-        this.reconcileTransaction = null;
-    },
-    perform: function(method, scope, a) {
-        return Transaction.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a);
-    }
-}), PooledClass_1.addPoolingTo(ReactUpdatesFlushTransaction);
-
-function batchedUpdates$1(callback, a, b, c, d, e) {
-    return ensureInjected(), batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
-}
-
-function mountOrderComparator(c1, c2) {
-    return c1._mountOrder - c2._mountOrder;
-}
-
-function runBatchedUpdates(transaction) {
-    var len = transaction.dirtyComponentsLength;
-    invariant(len === dirtyComponents.length, "Expected flush transaction's stored dirty-components length (%s) to " + "match dirty-components array length (%s).", len, dirtyComponents.length), 
-    dirtyComponents.sort(mountOrderComparator), updateBatchNumber++;
-    for (var i = 0; i < len; i++) {
-        var component = dirtyComponents[i];
-        ReactReconciler_1.performUpdateIfNecessary(component, transaction.reconcileTransaction, updateBatchNumber);
-    }
-}
-
-var flushBatchedUpdates = function() {
-    for (;dirtyComponents.length; ) {
-        var transaction = ReactUpdatesFlushTransaction.getPooled();
-        transaction.perform(runBatchedUpdates, null, transaction), ReactUpdatesFlushTransaction.release(transaction);
-    }
-};
-
-function enqueueUpdate$1(component) {
-    if (ensureInjected(), !batchingStrategy.isBatchingUpdates) return void batchingStrategy.batchedUpdates(enqueueUpdate$1, component);
-    dirtyComponents.push(component), null == component._updateBatchNumber && (component._updateBatchNumber = updateBatchNumber + 1);
-}
-
-var ReactUpdatesInjection = {
-    injectReconcileTransaction: function(ReconcileTransaction) {
-        invariant(ReconcileTransaction, "ReactUpdates: must provide a reconcile transaction class"), 
-        ReactUpdates.ReactReconcileTransaction = ReconcileTransaction;
-    },
-    injectBatchingStrategy: function(_batchingStrategy) {
-        invariant(_batchingStrategy, "ReactUpdates: must provide a batching strategy"), 
-        invariant("function" == typeof _batchingStrategy.batchedUpdates, "ReactUpdates: must provide a batchedUpdates() function"), 
-        invariant("boolean" == typeof _batchingStrategy.isBatchingUpdates, "ReactUpdates: must provide an isBatchingUpdates boolean attribute"), 
-        batchingStrategy = _batchingStrategy;
-    },
-    getBatchingStrategy: function() {
-        return batchingStrategy;
-    }
-}, ReactUpdates = {
-    ReactReconcileTransaction: null,
-    batchedUpdates: batchedUpdates$1,
-    enqueueUpdate: enqueueUpdate$1,
-    flushBatchedUpdates: flushBatchedUpdates,
-    injection: ReactUpdatesInjection
-}, ReactUpdates_1 = ReactUpdates, ReactCurrentOwner = ReactGlobalSharedState_1.ReactCurrentOwner, warning$3 = warning, warnOnInvalidCallback = function(callback, callerName) {
-    warning$3(null === callback || "function" == typeof callback, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, "" + callback);
-};
-
-function enqueueUpdate(internalInstance) {
-    ReactUpdates_1.enqueueUpdate(internalInstance);
-}
-
-function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
-    var internalInstance = ReactInstanceMap_1.get(publicInstance);
-    if (!internalInstance) {
-        var ctor = publicInstance.constructor;
-        return warning$3(!1, "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.", ctor && (ctor.displayName || ctor.name) || "ReactClass"), 
-        null;
-    }
-    return warning$3(null == ReactCurrentOwner.current, "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`."), 
-    internalInstance;
-}
-
-var ReactUpdateQueue = {
-    isMounted: function(publicInstance) {
-        var owner = ReactCurrentOwner.current;
-        null !== owner && (warning$3(owner._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.", owner.getName() || "A component"), 
-        owner._warnedAboutRefsInRender = !0);
-        var internalInstance = ReactInstanceMap_1.get(publicInstance);
-        return !!internalInstance && !!internalInstance._renderedComponent;
-    },
-    enqueueCallbackInternal: function(internalInstance, callback) {
-        internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ], 
-        enqueueUpdate(internalInstance);
-    },
-    enqueueForceUpdate: function(publicInstance, callback, callerName) {
-        var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
-        internalInstance && (callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
-        internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
-        internalInstance._pendingForceUpdate = !0, enqueueUpdate(internalInstance));
-    },
-    enqueueReplaceState: function(publicInstance, completeState, callback, callerName) {
-        var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
-        internalInstance && (internalInstance._pendingStateQueue = [ completeState ], internalInstance._pendingReplaceState = !0, 
-        callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
-        internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
-        enqueueUpdate(internalInstance));
-    },
-    enqueueSetState: function(publicInstance, partialState, callback, callerName) {
-        ReactInstrumentation.debugTool.onSetState(), warning$3(null != partialState, "setState(...): You passed an undefined or null state object; " + "instead, use forceUpdate().");
-        var internalInstance = getInternalInstanceReadyForUpdate(publicInstance);
-        if (internalInstance) {
-            (internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = [])).push(partialState), 
-            callback = void 0 === callback ? null : callback, null !== callback && (warnOnInvalidCallback(callback, callerName), 
-            internalInstance._pendingCallbacks ? internalInstance._pendingCallbacks.push(callback) : internalInstance._pendingCallbacks = [ callback ]), 
-            enqueueUpdate(internalInstance);
-        }
-    },
-    enqueueElementInternal: function(internalInstance, nextElement, nextContext) {
-        internalInstance._pendingElement = nextElement, internalInstance._context = nextContext, 
-        enqueueUpdate(internalInstance);
-    }
-}, ReactUpdateQueue_1 = ReactUpdateQueue, injected = !1, ReactComponentEnvironment = {
-    replaceNodeWithMarkup: null,
-    processChildrenUpdates: null,
-    injection: {
-        injectEnvironment: function(environment) {
-            invariant(!injected, "ReactCompositeComponent: injectEnvironment() can only be called once."), 
-            ReactComponentEnvironment.replaceNodeWithMarkup = environment.replaceNodeWithMarkup, 
-            ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates, 
-            injected = !0;
-        }
-    }
-}, ReactComponentEnvironment_1 = ReactComponentEnvironment, ReactNodeTypes = {
-    HOST: 0,
-    COMPOSITE: 1,
-    EMPTY: 2,
-    getType: function(node) {
-        return null === node || !1 === node ? ReactNodeTypes.EMPTY : React.isValidElement(node) ? "function" == typeof node.type ? ReactNodeTypes.COMPOSITE : ReactNodeTypes.HOST : void invariant(!1, "Unexpected node: %s", node);
-    }
-}, ReactNodeTypes_1 = ReactNodeTypes;
-
-function shouldUpdateReactComponent(prevElement, nextElement) {
-    var prevEmpty = null === prevElement || !1 === prevElement, nextEmpty = null === nextElement || !1 === nextElement;
-    if (prevEmpty || nextEmpty) return prevEmpty === nextEmpty;
-    var prevType = typeof prevElement, nextType = typeof nextElement;
-    return "string" === prevType || "number" === prevType ? "string" === nextType || "number" === nextType : "object" === nextType && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
-}
-
-var shouldUpdateReactComponent_1 = shouldUpdateReactComponent, ReactCurrentOwner$1 = ReactGlobalSharedState_1.ReactCurrentOwner, _require2 = ReactGlobalSharedState_1, ReactDebugCurrentFrame = _require2.ReactDebugCurrentFrame, warningAboutMissingGetChildContext = {};
-
-function StatelessComponent(Component) {}
-
-StatelessComponent.prototype.render = function() {
-    return (0, ReactInstanceMap_1.get(this)._currentElement.type)(this.props, this.context, this.updater);
-};
-
-function shouldConstruct(Component) {
-    return !(!Component.prototype || !Component.prototype.isReactComponent);
-}
-
-function isPureComponent(Component) {
-    return !(!Component.prototype || !Component.prototype.isPureReactComponent);
-}
-
-function measureLifeCyclePerf(fn, debugID, timerType) {
-    if (0 === debugID) return fn();
-    ReactInstrumentation.debugTool.onBeginLifeCycleTimer(debugID, timerType);
-    try {
-        return fn();
-    } finally {
-        ReactInstrumentation.debugTool.onEndLifeCycleTimer(debugID, timerType);
-    }
-}
-
-var nextMountID = 1, ReactCompositeComponent = {
-    construct: function(element) {
-        this._currentElement = element, this._rootNodeID = 0, this._compositeType = null, 
-        this._instance = null, this._hostParent = null, this._hostContainerInfo = null, 
-        this._updateBatchNumber = null, this._pendingElement = null, this._pendingStateQueue = null, 
-        this._pendingReplaceState = !1, this._pendingForceUpdate = !1, this._renderedNodeType = null, 
-        this._renderedComponent = null, this._context = null, this._mountOrder = 0, this._topLevelWrapper = null, 
-        this._pendingCallbacks = null, this._calledComponentWillUnmount = !1, this._warnedAboutRefsInRender = !1;
-    },
-    mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
-        var _this = this;
-        this._context = context, this._mountOrder = nextMountID++, this._hostParent = hostParent, 
-        this._hostContainerInfo = hostContainerInfo;
-        var renderedElement, publicProps = this._currentElement.props, publicContext = this._processContext(context), Component = this._currentElement.type, updateQueue = transaction.getUpdateQueue(), doConstruct = shouldConstruct(Component), inst = this._constructComponent(doConstruct, publicProps, publicContext, updateQueue);
-        doConstruct || null != inst && null != inst.render ? isPureComponent(Component) ? this._compositeType = ReactCompositeComponentTypes$1.PureClass : this._compositeType = ReactCompositeComponentTypes$1.ImpureClass : (renderedElement = inst, 
-        warning(!Component.childContextTypes, "%s(...): childContextTypes cannot be defined on a functional component.", Component.displayName || Component.name || "Component"), 
-        invariant(null === inst || !1 === inst || React.isValidElement(inst), "%s(...): A valid React element (or null) must be returned. You may have " + "returned undefined, an array or some other invalid object.", Component.displayName || Component.name || "Component"), 
-        inst = new StatelessComponent(Component), this._compositeType = ReactCompositeComponentTypes$1.StatelessFunctional), 
-        null == inst.render && warning(!1, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", Component.displayName || Component.name || "Component");
-        var propsMutated = inst.props !== publicProps, componentName = Component.displayName || Component.name || "Component";
-        warning(void 0 === inst.props || !propsMutated, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", componentName, componentName), 
-        inst.props = publicProps, inst.context = publicContext, inst.refs = emptyObject, 
-        inst.updater = updateQueue, this._instance = inst, ReactInstanceMap_1.set(inst, this), 
-        warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved || inst.state, "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?", this.getName() || "a component"), 
-        warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, "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.", this.getName() || "a component"), 
-        warning(!inst.propTypes, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", this.getName() || "a component"), 
-        warning(!inst.contextTypes, "contextTypes was defined as an instance property on %s. Use a " + "static property to define contextTypes instead.", this.getName() || "a component"), 
-        warning("function" != typeof inst.componentShouldUpdate, "%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.", this.getName() || "A component"), 
-        warning("function" != typeof inst.componentDidUnmount, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", this.getName() || "A component"), 
-        warning("function" != typeof inst.componentWillRecieveProps, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", this.getName() || "A component"), 
-        isPureComponent(Component) && void 0 !== inst.shouldComponentUpdate && warning(!1, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", this.getName() || "A pure component"), 
-        warning(!inst.defaultProps, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", this.getName() || "a component", this.getName() || "a component");
-        var initialState = inst.state;
-        void 0 === initialState && (inst.state = initialState = null), invariant("object" == typeof initialState && !Array.isArray(initialState), "%s.state: must be set to an object or null", this.getName() || "ReactCompositeComponent"), 
-        this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, 
-        inst.componentWillMount && (measureLifeCyclePerf(function() {
-            return inst.componentWillMount();
-        }, this._debugID, "componentWillMount"), this._pendingStateQueue && (inst.state = this._processPendingState(inst.props, inst.context)));
-        var markup;
-        markup = inst.unstable_handleError ? this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context) : this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context), 
-        inst.componentDidMount && transaction.getReactMountReady().enqueue(function() {
-            measureLifeCyclePerf(function() {
-                return inst.componentDidMount();
-            }, _this._debugID, "componentDidMount");
-        });
-        var callbacks = this._pendingCallbacks;
-        if (callbacks) {
-            this._pendingCallbacks = null;
-            for (var i = 0; i < callbacks.length; i++) transaction.getReactMountReady().enqueue(callbacks[i], inst);
-        }
-        return markup;
-    },
-    _constructComponent: function(doConstruct, publicProps, publicContext, updateQueue) {
-        ReactCurrentOwner$1.current = this;
-        try {
-            return this._constructComponentWithoutOwner(doConstruct, publicProps, publicContext, updateQueue);
-        } finally {
-            ReactCurrentOwner$1.current = null;
-        }
-    },
-    _constructComponentWithoutOwner: function(doConstruct, publicProps, publicContext, updateQueue) {
-        var Component = this._currentElement.type;
-        return doConstruct ? measureLifeCyclePerf(function() {
-            return new Component(publicProps, publicContext, updateQueue);
-        }, this._debugID, "ctor") : measureLifeCyclePerf(function() {
-            return Component(publicProps, publicContext, updateQueue);
-        }, this._debugID, "render");
-    },
-    performInitialMountWithErrorHandling: function(renderedElement, hostParent, hostContainerInfo, transaction, context) {
-        var markup, checkpoint = transaction.checkpoint();
-        try {
-            markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
-        } catch (e) {
-            transaction.rollback(checkpoint), this._instance.unstable_handleError(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
-            checkpoint = transaction.checkpoint(), this._renderedComponent.unmountComponent(!0, !0), 
-            transaction.rollback(checkpoint), markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
-        }
-        return markup;
-    },
-    performInitialMount: function(renderedElement, hostParent, hostContainerInfo, transaction, context) {
-        void 0 === renderedElement && (renderedElement = this._renderValidatedComponent());
-        var nodeType = ReactNodeTypes_1.getType(renderedElement);
-        this._renderedNodeType = nodeType;
-        var child = this._instantiateReactComponent(renderedElement, nodeType !== ReactNodeTypes_1.EMPTY);
-        this._renderedComponent = child;
-        var debugID = 0;
-        debugID = this._debugID;
-        var markup = ReactReconciler_1.mountComponent(child, transaction, hostParent, hostContainerInfo, this._processChildContext(context), debugID);
-        if (0 !== debugID) {
-            var childDebugIDs = 0 !== child._debugID ? [ child._debugID ] : [];
-            ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
-        }
-        return markup;
-    },
-    getHostNode: function() {
-        return ReactReconciler_1.getHostNode(this._renderedComponent);
-    },
-    unmountComponent: function(safely, skipLifecycle) {
-        if (this._renderedComponent) {
-            var inst = this._instance;
-            if (inst.componentWillUnmount && !inst._calledComponentWillUnmount) if (inst._calledComponentWillUnmount = !0, 
-            safely) {
-                if (!skipLifecycle) {
-                    var name = this.getName() + ".componentWillUnmount()";
-                    ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(name, inst.componentWillUnmount, inst);
+    }, ReactDefaultBatchingStrategy_1 = ReactDefaultBatchingStrategy, dangerouslyProcessChildrenUpdates = function(inst, childrenUpdates) {
+        if (childrenUpdates.length) {
+            for (var moveFromIndices, moveToIndices, addChildTags, addAtIndices, removeAtIndices, containerTag = ReactNativeComponentTree_1.getNodeFromInstance(inst), i = 0; i < childrenUpdates.length; i++) {
+                var update = childrenUpdates[i];
+                if ("MOVE_EXISTING" === update.type) (moveFromIndices || (moveFromIndices = [])).push(update.fromIndex), 
+                (moveToIndices || (moveToIndices = [])).push(update.toIndex); else if ("REMOVE_NODE" === update.type) (removeAtIndices || (removeAtIndices = [])).push(update.fromIndex); else if ("INSERT_MARKUP" === update.type) {
+                    var mountImage = update.content, tag = mountImage;
+                    (addAtIndices || (addAtIndices = [])).push(update.toIndex), (addChildTags || (addChildTags = [])).push(tag);
                 }
-            } else measureLifeCyclePerf(function() {
-                return inst.componentWillUnmount();
-            }, this._debugID, "componentWillUnmount");
-            this._renderedComponent && (ReactReconciler_1.unmountComponent(this._renderedComponent, safely, skipLifecycle), 
-            this._renderedNodeType = null, this._renderedComponent = null, this._instance = null), 
-            this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, 
-            this._pendingCallbacks = null, this._pendingElement = null, this._context = null, 
-            this._rootNodeID = 0, this._topLevelWrapper = null, ReactInstanceMap_1.remove(inst);
-        }
-    },
-    _maskContext: function(context) {
-        var Component = this._currentElement.type, contextTypes = Component.contextTypes;
-        if (!contextTypes) return emptyObject;
-        var maskedContext = {};
-        for (var contextName in contextTypes) maskedContext[contextName] = context[contextName];
-        return maskedContext;
-    },
-    _processContext: function(context) {
-        var maskedContext = this._maskContext(context), Component = this._currentElement.type;
-        return Component.contextTypes && this._checkContextTypes(Component.contextTypes, maskedContext, "context"), 
-        maskedContext;
-    },
-    _processChildContext: function(currentContext) {
-        var childContext, Component = this._currentElement.type, inst = this._instance;
-        if ("function" == typeof inst.getChildContext) {
-            ReactInstrumentation.debugTool.onBeginProcessingChildContext();
-            try {
-                childContext = inst.getChildContext();
-            } finally {
-                ReactInstrumentation.debugTool.onEndProcessingChildContext();
             }
-            invariant("object" == typeof Component.childContextTypes, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", this.getName() || "ReactCompositeComponent"), 
-            this._checkContextTypes(Component.childContextTypes, childContext, "child context");
-            for (var name in childContext) invariant(name in Component.childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || "ReactCompositeComponent", name);
-            return Object.assign({}, currentContext, childContext);
+            UIManager.manageChildren(containerTag, moveFromIndices, moveToIndices, addChildTags, addAtIndices, removeAtIndices);
         }
-        var componentName = this.getName();
-        return warningAboutMissingGetChildContext[componentName] || (warningAboutMissingGetChildContext[componentName] = !0, 
-        warning(!Component.childContextTypes, "%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)), 
-        currentContext;
-    },
-    _checkContextTypes: function(typeSpecs, values, location) {
-        ReactDebugCurrentFrame.current = this._debugID, checkPropTypes(typeSpecs, values, location, this.getName(), ReactDebugCurrentFrame.getStackAddendum), 
-        ReactDebugCurrentFrame.current = null;
-    },
-    receiveComponent: function(nextElement, transaction, nextContext) {
-        var prevElement = this._currentElement, prevContext = this._context;
-        this._pendingElement = null, this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext);
-    },
-    performUpdateIfNecessary: function(transaction) {
-        if (null != this._pendingElement) ReactReconciler_1.receiveComponent(this, this._pendingElement, transaction, this._context); else if (null !== this._pendingStateQueue || this._pendingForceUpdate) this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context); else {
-            var callbacks = this._pendingCallbacks;
-            if (this._pendingCallbacks = null, callbacks) for (var j = 0; j < callbacks.length; j++) transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
-            this._updateBatchNumber = null;
+    }, ReactNativeDOMIDOperations = {
+        dangerouslyProcessChildrenUpdates: dangerouslyProcessChildrenUpdates,
+        dangerouslyReplaceNodeWithMarkupByID: function(id, mountImage) {
+            var oldTag = id;
+            UIManager.replaceExistingNonRootView(oldTag, mountImage);
         }
-    },
-    updateComponent: function(transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) {
-        var inst = this._instance;
-        invariant(null != inst, "Attempted to update component `%s` that has already been unmounted " + "(or failed to mount).", this.getName() || "ReactCompositeComponent");
-        var nextContext, willReceive = !1;
-        this._context === nextUnmaskedContext ? nextContext = inst.context : (nextContext = this._processContext(nextUnmaskedContext), 
-        willReceive = !0);
-        var prevProps = prevParentElement.props, nextProps = nextParentElement.props;
-        if (prevParentElement !== nextParentElement && (willReceive = !0), willReceive && inst.componentWillReceiveProps) {
-            var beforeState = inst.state;
-            measureLifeCyclePerf(function() {
-                return inst.componentWillReceiveProps(nextProps, nextContext);
-            }, this._debugID, "componentWillReceiveProps");
-            var afterState = inst.state;
-            beforeState !== afterState && (inst.state = beforeState, inst.updater.enqueueReplaceState(inst, afterState), 
-            warning(!1, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", this.getName() || "ReactCompositeComponent"));
+    }, ReactNativeDOMIDOperations_1 = ReactNativeDOMIDOperations;
+    function validateCallback(callback) {
+        invariant(!callback || "function" == typeof callback, "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", callback);
+    }
+    var validateCallback_1 = validateCallback;
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    var CallbackQueue = function() {
+        function CallbackQueue() {
+            _classCallCheck(this, CallbackQueue), this._callbacks = null, this._contexts = null;
         }
-        var callbacks = this._pendingCallbacks;
-        this._pendingCallbacks = null;
-        var nextState = this._processPendingState(nextProps, nextContext), shouldUpdate = !0;
-        if (!this._pendingForceUpdate) {
-            var prevState = inst.state;
-            shouldUpdate = willReceive || nextState !== prevState, inst.shouldComponentUpdate ? shouldUpdate = measureLifeCyclePerf(function() {
-                return inst.shouldComponentUpdate(nextProps, nextState, nextContext);
-            }, this._debugID, "shouldComponentUpdate") : this._compositeType === ReactCompositeComponentTypes$1.PureClass && (shouldUpdate = !shallowEqual(prevProps, nextProps) || !shallowEqual(inst.state, nextState));
-        }
-        if (warning(void 0 !== shouldUpdate, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", this.getName() || "ReactCompositeComponent"), 
-        this._updateBatchNumber = null, shouldUpdate ? (this._pendingForceUpdate = !1, this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext)) : (this._currentElement = nextParentElement, 
-        this._context = nextUnmaskedContext, inst.props = nextProps, inst.state = nextState, 
-        inst.context = nextContext), callbacks) for (var j = 0; j < callbacks.length; j++) transaction.getReactMountReady().enqueue(callbacks[j], this.getPublicInstance());
-    },
-    _processPendingState: function(props, context) {
-        var inst = this._instance, queue = this._pendingStateQueue, replace = this._pendingReplaceState;
-        if (this._pendingReplaceState = !1, this._pendingStateQueue = null, !queue) return inst.state;
-        if (replace && 1 === queue.length) return queue[0];
-        for (var nextState = replace ? queue[0] : inst.state, dontMutate = !0, i = replace ? 1 : 0; i < queue.length; i++) {
-            var partial = queue[i], partialState = "function" == typeof partial ? partial.call(inst, nextState, props, context) : partial;
-            partialState && (dontMutate ? (dontMutate = !1, nextState = Object.assign({}, nextState, partialState)) : Object.assign(nextState, partialState));
-        }
-        return nextState;
-    },
-    _performComponentUpdate: function(nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) {
-        var prevProps, prevState, _this2 = this, inst = this._instance, hasComponentDidUpdate = !!inst.componentDidUpdate;
-        hasComponentDidUpdate && (prevProps = inst.props, prevState = inst.state), inst.componentWillUpdate && measureLifeCyclePerf(function() {
-            return inst.componentWillUpdate(nextProps, nextState, nextContext);
-        }, this._debugID, "componentWillUpdate"), this._currentElement = nextElement, this._context = unmaskedContext, 
-        inst.props = nextProps, inst.state = nextState, inst.context = nextContext, inst.unstable_handleError ? this._updateRenderedComponentWithErrorHandling(transaction, unmaskedContext) : this._updateRenderedComponent(transaction, unmaskedContext), 
-        hasComponentDidUpdate && transaction.getReactMountReady().enqueue(function() {
-            measureLifeCyclePerf(inst.componentDidUpdate.bind(inst, prevProps, prevState), _this2._debugID, "componentDidUpdate");
-        });
-    },
-    _updateRenderedComponentWithErrorHandling: function(transaction, context) {
-        var checkpoint = transaction.checkpoint();
-        try {
-            this._updateRenderedComponent(transaction, context);
-        } catch (e) {
-            transaction.rollback(checkpoint), this._instance.unstable_handleError(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
-            checkpoint = transaction.checkpoint(), this._updateRenderedComponentWithNextElement(transaction, context, null, !0), 
-            this._updateRenderedComponent(transaction, context);
-        }
-    },
-    _updateRenderedComponent: function(transaction, context) {
-        var nextRenderedElement = this._renderValidatedComponent();
-        this._updateRenderedComponentWithNextElement(transaction, context, nextRenderedElement, !1);
-    },
-    _updateRenderedComponentWithNextElement: function(transaction, context, nextRenderedElement, safely) {
-        var prevComponentInstance = this._renderedComponent, prevRenderedElement = prevComponentInstance._currentElement, debugID = 0;
-        if (debugID = this._debugID, shouldUpdateReactComponent_1(prevRenderedElement, nextRenderedElement)) ReactReconciler_1.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context)); else {
-            var oldHostNode = ReactReconciler_1.getHostNode(prevComponentInstance), nodeType = ReactNodeTypes_1.getType(nextRenderedElement);
-            this._renderedNodeType = nodeType;
-            var child = this._instantiateReactComponent(nextRenderedElement, nodeType !== ReactNodeTypes_1.EMPTY);
-            this._renderedComponent = child;
-            var nextMarkup = ReactReconciler_1.mountComponent(child, transaction, this._hostParent, this._hostContainerInfo, this._processChildContext(context), debugID);
-            if (ReactReconciler_1.unmountComponent(prevComponentInstance, safely, !1), 0 !== debugID) {
-                var childDebugIDs = 0 !== child._debugID ? [ child._debugID ] : [];
-                ReactInstrumentation.debugTool.onSetChildren(debugID, childDebugIDs);
+        return CallbackQueue.prototype.enqueue = function(callback, context) {
+            this._callbacks = this._callbacks || [], this._callbacks.push(callback), this._contexts = this._contexts || [], 
+            this._contexts.push(context);
+        }, CallbackQueue.prototype.notifyAll = function() {
+            var callbacks = this._callbacks, contexts = this._contexts;
+            if (callbacks && contexts) {
+                invariant(callbacks.length === contexts.length, "Mismatched list of contexts in callback queue"), 
+                this._callbacks = null, this._contexts = null;
+                for (var i = 0; i < callbacks.length; i++) validateCallback_1(callbacks[i]), callbacks[i].call(contexts[i]);
+                callbacks.length = 0, contexts.length = 0;
             }
-            this._replaceNodeWithMarkup(oldHostNode, nextMarkup, prevComponentInstance);
-        }
-    },
-    _replaceNodeWithMarkup: function(oldHostNode, nextMarkup, prevInstance) {
-        ReactComponentEnvironment_1.replaceNodeWithMarkup(oldHostNode, nextMarkup, prevInstance);
-    },
-    _renderValidatedComponentWithoutOwnerOrContext: function() {
-        var renderedElement, inst = this._instance;
-        return renderedElement = measureLifeCyclePerf(function() {
-            return inst.render();
-        }, this._debugID, "render"), void 0 === renderedElement && inst.render._isMockFunction && (renderedElement = null), 
-        renderedElement;
-    },
-    _renderValidatedComponent: function() {
-        var renderedElement;
-        if (0 && this._compositeType === ReactCompositeComponentTypes$1.StatelessFunctional) renderedElement = this._renderValidatedComponentWithoutOwnerOrContext(); else {
-            ReactCurrentOwner$1.current = this;
-            try {
-                renderedElement = this._renderValidatedComponentWithoutOwnerOrContext();
-            } finally {
-                ReactCurrentOwner$1.current = null;
-            }
-        }
-        return invariant(null === renderedElement || !1 === renderedElement || React.isValidElement(renderedElement), "%s.render(): A valid React element (or null) must be returned. You may have " + "returned undefined, an array or some other invalid object.", this.getName() || "ReactCompositeComponent"), 
-        renderedElement;
-    },
-    attachRef: function(ref, component) {
-        var inst = this.getPublicInstance();
-        invariant(null != inst, "Stateless function components cannot have refs.");
-        var publicComponentInstance = component.getPublicInstance();
-        (inst.refs === emptyObject ? inst.refs = {} : inst.refs)[ref] = publicComponentInstance;
-    },
-    detachRef: function(ref) {
-        delete this.getPublicInstance().refs[ref];
-    },
-    getName: function() {
-        var type = this._currentElement.type, constructor = this._instance && this._instance.constructor;
-        return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null;
-    },
-    getPublicInstance: function() {
-        var inst = this._instance;
-        return this._compositeType === ReactCompositeComponentTypes$1.StatelessFunctional ? null : inst;
-    },
-    _instantiateReactComponent: null
-}, ReactCompositeComponent_1 = ReactCompositeComponent, emptyComponentFactory, ReactEmptyComponentInjection = {
-    injectEmptyComponentFactory: function(factory) {
-        emptyComponentFactory = factory;
-    }
-}, ReactEmptyComponent = {
-    create: function(instantiate) {
-        return emptyComponentFactory(instantiate);
-    }
-};
-
-ReactEmptyComponent.injection = ReactEmptyComponentInjection;
-
-var ReactEmptyComponent_1 = ReactEmptyComponent, genericComponentClass = null, textComponentClass = null, ReactHostComponentInjection = {
-    injectGenericComponentClass: function(componentClass) {
-        genericComponentClass = componentClass;
-    },
-    injectTextComponentClass: function(componentClass) {
-        textComponentClass = componentClass;
-    }
-};
-
-function createInternalComponent(element) {
-    return invariant(genericComponentClass, "There is no registered component for the tag %s", element.type), 
-    new genericComponentClass(element);
-}
-
-function createInstanceForText(text) {
-    return new textComponentClass(text);
-}
-
-function isTextComponent(component) {
-    return component instanceof textComponentClass;
-}
-
-var ReactHostComponent = {
-    createInternalComponent: createInternalComponent,
-    createInstanceForText: createInstanceForText,
-    isTextComponent: isTextComponent,
-    injection: ReactHostComponentInjection
-}, ReactHostComponent_1 = ReactHostComponent, nextDebugID = 1, ReactCompositeComponentWrapper = function(element) {
-    this.construct(element);
-};
-
-function getDeclarationErrorAddendum(owner) {
-    if (owner) {
-        var name = owner.getName();
-        if (name) return "\n\nCheck the render method of `" + name + "`.";
-    }
-    return "";
-}
-
-function isInternalComponentType(type) {
-    return "function" == typeof type && void 0 !== type.prototype && "function" == typeof type.prototype.mountComponent && "function" == typeof type.prototype.receiveComponent;
-}
-
-function instantiateReactComponent(node, shouldHaveDebugID) {
-    var instance;
-    if (null === node || !1 === node) instance = ReactEmptyComponent_1.create(instantiateReactComponent); else if ("object" == typeof node) {
-        var element = node, type = element.type;
-        if ("function" != typeof type && "string" != typeof type) {
-            var info = "";
-            (void 0 === type || "object" == typeof type && null !== type && 0 === Object.keys(type).length) && (info += " You likely forgot to export your component from the file " + "it's defined in."), 
-            info += getDeclarationErrorAddendum(element._owner), invariant(!1, "Element type is invalid: expected a string (for built-in components) " + "or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, info);
-        }
-        "string" == typeof element.type ? instance = ReactHostComponent_1.createInternalComponent(element) : isInternalComponentType(element.type) ? (instance = new element.type(element), 
-        instance.getHostNode || (instance.getHostNode = instance.getNativeNode)) : instance = new ReactCompositeComponentWrapper(element);
-    } else "string" == typeof node || "number" == typeof node ? instance = ReactHostComponent_1.createInstanceForText(node) : invariant(!1, "Encountered invalid React node of type %s", typeof node);
-    return warning("function" == typeof instance.mountComponent && "function" == typeof instance.receiveComponent && "function" == typeof instance.getHostNode && "function" == typeof instance.unmountComponent, "Only React Components can be mounted."), 
-    instance._mountIndex = 0, instance._mountImage = null, instance._debugID = shouldHaveDebugID ? nextDebugID++ : 0, 
-    Object.preventExtensions && Object.preventExtensions(instance), instance;
-}
-
-Object.assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent_1, {
-    _instantiateReactComponent: instantiateReactComponent
-});
-
-var instantiateReactComponent_1 = instantiateReactComponent, DevOnlyStubShim = null, ReactNativeFeatureFlags = require("ReactNativeFeatureFlags"), ReactCurrentOwner$2 = ReactGlobalSharedState_1.ReactCurrentOwner, injectedFindNode = ReactNativeFeatureFlags.useFiber ? function(fiber) {
-    return DevOnlyStubShim.findHostInstance(fiber);
-} : function(instance) {
-    return instance;
-};
-
-function findNodeHandle(componentOrHandle) {
-    var owner = ReactCurrentOwner$2.current;
-    if (null !== owner && (warning(owner._warnedAboutRefsInRender, "%s is accessing findNodeHandle 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.", owner.getName() || "A component"), 
-    owner._warnedAboutRefsInRender = !0), null == componentOrHandle) return null;
-    if ("number" == typeof componentOrHandle) return componentOrHandle;
-    var component = componentOrHandle, internalInstance = ReactInstanceMap_1.get(component);
-    return internalInstance ? injectedFindNode(internalInstance) : component || (invariant("object" == typeof component && ("_rootNodeID" in component || "_nativeTag" in component) || null != component.render && "function" == typeof component.render, "findNodeHandle(...): Argument is not a component " + "(type: %s, keys: %s)", typeof component, Object.keys(component)), 
-    void invariant(!1, "findNodeHandle(...): Unable to find node handle for unmounted " + "component."));
-}
-
-var findNodeHandle_1 = findNodeHandle, TopLevelWrapper = function() {};
-
-TopLevelWrapper.prototype.isReactComponent = {}, TopLevelWrapper.displayName = "TopLevelWrapper", 
-TopLevelWrapper.prototype.render = function() {
-    return this.props.child;
-}, TopLevelWrapper.isReactTopLevelWrapper = !0;
-
-function mountComponentIntoNode(componentInstance, containerTag, transaction) {
-    var markup = ReactReconciler_1.mountComponent(componentInstance, transaction, null, ReactNativeContainerInfo_1(containerTag), emptyObject, 0);
-    componentInstance._renderedComponent._topLevelWrapper = componentInstance, ReactNativeMount._mountImageIntoNode(markup, containerTag);
-}
-
-function batchedMountComponentIntoNode(componentInstance, containerTag) {
-    var transaction = ReactUpdates_1.ReactReconcileTransaction.getPooled();
-    transaction.perform(mountComponentIntoNode, null, componentInstance, containerTag, transaction), 
-    ReactUpdates_1.ReactReconcileTransaction.release(transaction);
-}
-
-var ReactNativeMount = {
-    _instancesByContainerID: {},
-    findNodeHandle: findNodeHandle_1,
-    renderComponent: function(nextElement, containerTag, callback) {
-        var nextWrappedElement = React.createElement(TopLevelWrapper, {
-            child: nextElement
-        }), topRootNodeID = containerTag, prevComponent = ReactNativeMount._instancesByContainerID[topRootNodeID];
-        if (prevComponent) {
-            var prevWrappedElement = prevComponent._currentElement, prevElement = prevWrappedElement.props.child;
-            if (shouldUpdateReactComponent_1(prevElement, nextElement)) return ReactUpdateQueue_1.enqueueElementInternal(prevComponent, nextWrappedElement, emptyObject), 
-            callback && ReactUpdateQueue_1.enqueueCallbackInternal(prevComponent, callback), 
-            prevComponent;
-            ReactNativeMount.unmountComponentAtNode(containerTag);
-        }
-        if (!ReactNativeTagHandles_1.reactTagIsNativeTopRootID(containerTag)) return console.error("You cannot render into anything but a top root"), 
-        null;
-        ReactNativeTagHandles_1.assertRootTag(containerTag);
-        var instance = instantiateReactComponent_1(nextWrappedElement, !1);
-        if (ReactNativeMount._instancesByContainerID[containerTag] = instance, callback) {
-            var nonNullCallback = callback;
-            instance._pendingCallbacks = [ function() {
-                nonNullCallback.call(instance._renderedComponent.getPublicInstance());
-            } ];
-        }
-        return ReactUpdates_1.batchedUpdates(batchedMountComponentIntoNode, instance, containerTag), 
-        instance._renderedComponent.getPublicInstance();
-    },
-    _mountImageIntoNode: function(mountImage, containerID) {
-        var childTag = mountImage;
-        UIManager.setChildren(containerID, [ childTag ]);
-    },
-    unmountComponentAtNodeAndRemoveContainer: function(containerTag) {
-        ReactNativeMount.unmountComponentAtNode(containerTag), UIManager.removeRootView(containerTag);
-    },
-    unmountComponentAtNode: function(containerTag) {
-        if (!ReactNativeTagHandles_1.reactTagIsNativeTopRootID(containerTag)) return console.error("You cannot render into anything but a top root"), 
-        !1;
-        var instance = ReactNativeMount._instancesByContainerID[containerTag];
-        return !!instance && (ReactInstrumentation.debugTool.onBeginFlush(), ReactNativeMount.unmountComponentFromNode(instance, containerTag), 
-        delete ReactNativeMount._instancesByContainerID[containerTag], ReactInstrumentation.debugTool.onEndFlush(), 
-        !0);
-    },
-    unmountComponentFromNode: function(instance, containerID) {
-        ReactReconciler_1.unmountComponent(instance), UIManager.removeSubviewsFromContainerWithID(containerID);
-    }
-}, ReactNativeMount_1 = ReactNativeMount, RESET_BATCHED_UPDATES = {
-    initialize: emptyFunction,
-    close: function() {
-        ReactDefaultBatchingStrategy.isBatchingUpdates = !1;
-    }
-}, FLUSH_BATCHED_UPDATES = {
-    initialize: emptyFunction,
-    close: ReactUpdates_1.flushBatchedUpdates.bind(ReactUpdates_1)
-}, TRANSACTION_WRAPPERS$1 = [ FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES ];
-
-function ReactDefaultBatchingStrategyTransaction() {
-    this.reinitializeTransaction();
-}
-
-Object.assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction, {
-    getTransactionWrappers: function() {
-        return TRANSACTION_WRAPPERS$1;
-    }
-});
-
-var transaction = new ReactDefaultBatchingStrategyTransaction(), ReactDefaultBatchingStrategy = {
-    isBatchingUpdates: !1,
-    batchedUpdates: function(callback, a, b, c, d, e) {
-        var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates;
-        return ReactDefaultBatchingStrategy.isBatchingUpdates = !0, alreadyBatchingUpdates ? callback(a, b, c, d, e) : transaction.perform(callback, null, a, b, c, d, e);
-    }
-}, ReactDefaultBatchingStrategy_1 = ReactDefaultBatchingStrategy, dangerouslyProcessChildrenUpdates = function(inst, childrenUpdates) {
-    if (childrenUpdates.length) {
-        for (var moveFromIndices, moveToIndices, addChildTags, addAtIndices, removeAtIndices, containerTag = ReactNativeComponentTree_1.getNodeFromInstance(inst), i = 0; i < childrenUpdates.length; i++) {
-            var update = childrenUpdates[i];
-            if ("MOVE_EXISTING" === update.type) (moveFromIndices || (moveFromIndices = [])).push(update.fromIndex), 
-            (moveToIndices || (moveToIndices = [])).push(update.toIndex); else if ("REMOVE_NODE" === update.type) (removeAtIndices || (removeAtIndices = [])).push(update.fromIndex); else if ("INSERT_MARKUP" === update.type) {
-                var mountImage = update.content, tag = mountImage;
-                (addAtIndices || (addAtIndices = [])).push(update.toIndex), (addChildTags || (addChildTags = [])).push(tag);
-            }
-        }
-        UIManager.manageChildren(containerTag, moveFromIndices, moveToIndices, addChildTags, addAtIndices, removeAtIndices);
-    }
-}, ReactNativeDOMIDOperations = {
-    dangerouslyProcessChildrenUpdates: dangerouslyProcessChildrenUpdates,
-    dangerouslyReplaceNodeWithMarkupByID: function(id, mountImage) {
-        var oldTag = id;
-        UIManager.replaceExistingNonRootView(oldTag, mountImage);
-    }
-}, ReactNativeDOMIDOperations_1 = ReactNativeDOMIDOperations;
-
-function validateCallback(callback) {
-    invariant(!callback || "function" == typeof callback, "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", callback);
-}
-
-var validateCallback_1 = validateCallback;
-
-function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-var CallbackQueue = function() {
-    function CallbackQueue() {
-        _classCallCheck(this, CallbackQueue), this._callbacks = null, this._contexts = null;
-    }
-    return CallbackQueue.prototype.enqueue = function(callback, context) {
-        this._callbacks = this._callbacks || [], this._callbacks.push(callback), this._contexts = this._contexts || [], 
-        this._contexts.push(context);
-    }, CallbackQueue.prototype.notifyAll = function() {
-        var callbacks = this._callbacks, contexts = this._contexts;
-        if (callbacks && contexts) {
-            invariant(callbacks.length === contexts.length, "Mismatched list of contexts in callback queue"), 
+        }, CallbackQueue.prototype.checkpoint = function() {
+            return this._callbacks ? this._callbacks.length : 0;
+        }, CallbackQueue.prototype.rollback = function(len) {
+            this._callbacks && this._contexts && (this._callbacks.length = len, this._contexts.length = len);
+        }, CallbackQueue.prototype.reset = function() {
             this._callbacks = null, this._contexts = null;
-            for (var i = 0; i < callbacks.length; i++) validateCallback_1(callbacks[i]), callbacks[i].call(contexts[i]);
-            callbacks.length = 0, contexts.length = 0;
+        }, CallbackQueue.prototype.destructor = function() {
+            this.reset();
+        }, CallbackQueue;
+    }(), CallbackQueue_1 = PooledClass_1.addPoolingTo(CallbackQueue), ON_DOM_READY_QUEUEING = {
+        initialize: function() {
+            this.reactMountReady.reset();
+        },
+        close: function() {
+            this.reactMountReady.notifyAll();
         }
-    }, CallbackQueue.prototype.checkpoint = function() {
-        return this._callbacks ? this._callbacks.length : 0;
-    }, CallbackQueue.prototype.rollback = function(len) {
-        this._callbacks && this._contexts && (this._callbacks.length = len, this._contexts.length = len);
-    }, CallbackQueue.prototype.reset = function() {
-        this._callbacks = null, this._contexts = null;
-    }, CallbackQueue.prototype.destructor = function() {
-        this.reset();
-    }, CallbackQueue;
-}(), CallbackQueue_1 = PooledClass_1.addPoolingTo(CallbackQueue), ON_DOM_READY_QUEUEING = {
-    initialize: function() {
-        this.reactMountReady.reset();
-    },
-    close: function() {
-        this.reactMountReady.notifyAll();
+    }, TRANSACTION_WRAPPERS$2 = [ ON_DOM_READY_QUEUEING ];
+    TRANSACTION_WRAPPERS$2.push({
+        initialize: ReactInstrumentation.debugTool.onBeginFlush,
+        close: ReactInstrumentation.debugTool.onEndFlush
+    });
+    function ReactNativeReconcileTransaction() {
+        this.reinitializeTransaction(), this.reactMountReady = CallbackQueue_1.getPooled();
     }
-}, TRANSACTION_WRAPPERS$2 = [ ON_DOM_READY_QUEUEING ];
-
-TRANSACTION_WRAPPERS$2.push({
-    initialize: ReactInstrumentation.debugTool.onBeginFlush,
-    close: ReactInstrumentation.debugTool.onEndFlush
-});
-
-function ReactNativeReconcileTransaction() {
-    this.reinitializeTransaction(), this.reactMountReady = CallbackQueue_1.getPooled();
-}
-
-var Mixin = {
-    getTransactionWrappers: function() {
-        return TRANSACTION_WRAPPERS$2;
-    },
-    getReactMountReady: function() {
-        return this.reactMountReady;
-    },
-    getUpdateQueue: function() {
-        return ReactUpdateQueue_1;
-    },
-    checkpoint: function() {
-        return this.reactMountReady.checkpoint();
-    },
-    rollback: function(checkpoint) {
-        this.reactMountReady.rollback(checkpoint);
-    },
-    destructor: function() {
-        CallbackQueue_1.release(this.reactMountReady), this.reactMountReady = null;
-    }
-};
-
-Object.assign(ReactNativeReconcileTransaction.prototype, Transaction, ReactNativeReconcileTransaction, Mixin), 
-PooledClass_1.addPoolingTo(ReactNativeReconcileTransaction);
-
-var ReactNativeReconcileTransaction_1 = ReactNativeReconcileTransaction, ReactNativeComponentEnvironment = {
-    processChildrenUpdates: ReactNativeDOMIDOperations_1.dangerouslyProcessChildrenUpdates,
-    replaceNodeWithMarkup: ReactNativeDOMIDOperations_1.dangerouslyReplaceNodeWithMarkupByID,
-    clearNode: function() {},
-    ReactReconcileTransaction: ReactNativeReconcileTransaction_1
-}, ReactNativeComponentEnvironment_1 = ReactNativeComponentEnvironment, ReactNativeTextComponent = function(text) {
-    this._currentElement = text, this._stringText = "" + text, this._hostParent = null, 
-    this._rootNodeID = 0;
-};
-
-Object.assign(ReactNativeTextComponent.prototype, {
-    mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
-        invariant(context.isInAParentText, 'RawText "%s" must be wrapped in an explicit <Text> component.', this._stringText), 
-        this._hostParent = hostParent;
-        var tag = ReactNativeTagHandles_1.allocateTag();
-        this._rootNodeID = tag;
-        var nativeTopRootTag = hostContainerInfo._tag;
-        return UIManager.createView(tag, "RCTRawText", nativeTopRootTag, {
-            text: this._stringText
-        }), ReactNativeComponentTree_1.precacheNode(this, tag), tag;
-    },
-    getHostNode: function() {
-        return this._rootNodeID;
-    },
-    receiveComponent: function(nextText, transaction, context) {
-        if (nextText !== this._currentElement) {
-            this._currentElement = nextText;
-            var nextStringText = "" + nextText;
-            nextStringText !== this._stringText && (this._stringText = nextStringText, UIManager.updateView(this._rootNodeID, "RCTRawText", {
-                text: this._stringText
-            }));
+    var Mixin = {
+        getTransactionWrappers: function() {
+            return TRANSACTION_WRAPPERS$2;
+        },
+        getReactMountReady: function() {
+            return this.reactMountReady;
+        },
+        getUpdateQueue: function() {
+            return ReactUpdateQueue_1;
+        },
+        checkpoint: function() {
+            return this.reactMountReady.checkpoint();
+        },
+        rollback: function(checkpoint) {
+            this.reactMountReady.rollback(checkpoint);
+        },
+        destructor: function() {
+            CallbackQueue_1.release(this.reactMountReady), this.reactMountReady = null;
         }
-    },
-    unmountComponent: function() {
-        ReactNativeComponentTree_1.uncacheNode(this), this._currentElement = null, this._stringText = null, 
+    };
+    Object.assign(ReactNativeReconcileTransaction.prototype, Transaction, ReactNativeReconcileTransaction, Mixin), 
+    PooledClass_1.addPoolingTo(ReactNativeReconcileTransaction);
+    var ReactNativeReconcileTransaction_1 = ReactNativeReconcileTransaction, ReactNativeComponentEnvironment = {
+        processChildrenUpdates: ReactNativeDOMIDOperations_1.dangerouslyProcessChildrenUpdates,
+        replaceNodeWithMarkup: ReactNativeDOMIDOperations_1.dangerouslyReplaceNodeWithMarkupByID,
+        clearNode: function() {},
+        ReactReconcileTransaction: ReactNativeReconcileTransaction_1
+    }, ReactNativeComponentEnvironment_1 = ReactNativeComponentEnvironment, ReactNativeTextComponent = function(text) {
+        this._currentElement = text, this._stringText = "" + text, this._hostParent = null, 
         this._rootNodeID = 0;
-    }
-});
-
-var ReactNativeTextComponent_1 = ReactNativeTextComponent, ReactSimpleEmptyComponent = function(placeholderElement, instantiate) {
-    this._currentElement = null, this._renderedComponent = instantiate(placeholderElement);
-};
-
-Object.assign(ReactSimpleEmptyComponent.prototype, {
-    mountComponent: function(transaction, hostParent, hostContainerInfo, context, parentDebugID) {
-        return ReactReconciler_1.mountComponent(this._renderedComponent, transaction, hostParent, hostContainerInfo, context, parentDebugID);
-    },
-    receiveComponent: function() {},
-    getHostNode: function() {
-        return ReactReconciler_1.getHostNode(this._renderedComponent);
-    },
-    unmountComponent: function(safely, skipLifecycle) {
-        ReactReconciler_1.unmountComponent(this._renderedComponent, safely, skipLifecycle), 
-        this._renderedComponent = null;
-    }
-});
-
-var ReactSimpleEmptyComponent_1 = ReactSimpleEmptyComponent;
-
-function inject$1() {
+    };
+    Object.assign(ReactNativeTextComponent.prototype, {
+        mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
+            invariant(context.isInAParentText, 'RawText "%s" must be wrapped in an explicit <Text> component.', this._stringText), 
+            this._hostParent = hostParent;
+            var tag = ReactNativeTagHandles_1.allocateTag();
+            this._rootNodeID = tag;
+            var nativeTopRootTag = hostContainerInfo._tag;
+            return UIManager.createView(tag, "RCTRawText", nativeTopRootTag, {
+                text: this._stringText
+            }), ReactNativeComponentTree_1.precacheNode(this, tag), tag;
+        },
+        getHostNode: function() {
+            return this._rootNodeID;
+        },
+        receiveComponent: function(nextText, transaction, context) {
+            if (nextText !== this._currentElement) {
+                this._currentElement = nextText;
+                var nextStringText = "" + nextText;
+                nextStringText !== this._stringText && (this._stringText = nextStringText, UIManager.updateView(this._rootNodeID, "RCTRawText", {
+                    text: this._stringText
+                }));
+            }
+        },
+        unmountComponent: function() {
+            ReactNativeComponentTree_1.uncacheNode(this), this._currentElement = null, this._stringText = null, 
+            this._rootNodeID = 0;
+        }
+    });
+    var ReactNativeTextComponent_1 = ReactNativeTextComponent, ReactSimpleEmptyComponent = function(placeholderElement, instantiate) {
+        this._currentElement = null, this._renderedComponent = instantiate(placeholderElement);
+    };
+    Object.assign(ReactSimpleEmptyComponent.prototype, {
+        mountComponent: function(transaction, hostParent, hostContainerInfo, context, parentDebugID) {
+            return ReactReconciler_1.mountComponent(this._renderedComponent, transaction, hostParent, hostContainerInfo, context, parentDebugID);
+        },
+        receiveComponent: function() {},
+        getHostNode: function() {
+            return ReactReconciler_1.getHostNode(this._renderedComponent);
+        },
+        unmountComponent: function(safely, skipLifecycle) {
+            ReactReconciler_1.unmountComponent(this._renderedComponent, safely, skipLifecycle), 
+            this._renderedComponent = null;
+        }
+    });
+    var ReactSimpleEmptyComponent_1 = ReactSimpleEmptyComponent;
     ReactGenericBatching_1.injection.injectStackBatchedUpdates(ReactUpdates_1.batchedUpdates), 
     ReactUpdates_1.injection.injectReconcileTransaction(ReactNativeComponentEnvironment_1.ReactReconcileTransaction), 
     ReactUpdates_1.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy_1), 
@@ -2251,1048 +2172,883 @@ function inject$1() {
         "string" == typeof tag && /^[a-z]/.test(tag) && (info += " Each component name should start with an uppercase letter."), 
         invariant(!1, "Expected a component class, got %s.%s", tag, info);
     });
-}
-
-var ReactNativeStackInjection = {
-    inject: inject$1
-};
-
-function getComponentName(instanceOrFiber) {
-    if ("function" == typeof instanceOrFiber.getName) {
-        return instanceOrFiber.getName();
+    function _classCallCheck$2(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
     }
-    if ("number" == typeof instanceOrFiber.tag) {
-        var fiber = instanceOrFiber, type = fiber.type;
-        if ("string" == typeof type) return type;
-        if ("function" == typeof type) return type.displayName || type.name;
+    var objects = {}, uniqueID = 1, emptyObject$3 = {}, ReactNativePropRegistry = function() {
+        function ReactNativePropRegistry() {
+            _classCallCheck$2(this, ReactNativePropRegistry);
+        }
+        return ReactNativePropRegistry.register = function(object) {
+            var id = ++uniqueID;
+            return Object.freeze(object), objects[id] = object, id;
+        }, ReactNativePropRegistry.getByID = function(id) {
+            if (!id) return emptyObject$3;
+            var object = objects[id];
+            return object || (console.warn("Invalid style with id `" + id + "`. Skipping ..."), 
+            emptyObject$3);
+        }, ReactNativePropRegistry;
+    }(), ReactNativePropRegistry_1 = ReactNativePropRegistry, emptyObject$2 = {}, removedKeys = null, removedKeyCount = 0;
+    function defaultDiffer(prevProp, nextProp) {
+        return "object" != typeof nextProp || null === nextProp || deepDiffer(prevProp, nextProp);
     }
-    return null;
-}
-
-var getComponentName_1 = getComponentName, getInspectorDataForViewTag = void 0, traverseOwnerTreeUp = function(hierarchy, instance) {
-    instance && (hierarchy.unshift(instance), traverseOwnerTreeUp(hierarchy, instance._currentElement._owner));
-}, getOwnerHierarchy = function(instance) {
-    var hierarchy = [];
-    return traverseOwnerTreeUp(hierarchy, instance), hierarchy;
-}, lastNotNativeInstance = function(hierarchy) {
-    for (var i = hierarchy.length - 1; i > 1; i--) {
-        var instance = hierarchy[i];
-        if (!instance.viewConfig) return instance;
+    function resolveObject(idOrObject) {
+        return "number" == typeof idOrObject ? ReactNativePropRegistry_1.getByID(idOrObject) : idOrObject;
     }
-    return hierarchy[0];
-}, getHostProps = function(component) {
-    var instance = component._instance;
-    return instance ? instance.props || emptyObject : emptyObject;
-}, createHierarchy = function(componentHierarchy) {
-    return componentHierarchy.map(function(component) {
-        return {
-            name: getComponentName_1(component),
-            getInspectorData: function() {
-                return {
-                    measure: function(callback) {
-                        return UIManager.measure(component.getHostNode(), callback);
-                    },
-                    props: getHostProps(component),
-                    source: component._currentElement && component._currentElement._source
-                };
+    function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
+        if (Array.isArray(node)) for (var i = node.length; i-- && removedKeyCount > 0; ) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes); else if (node && removedKeyCount > 0) {
+            var obj = resolveObject(node);
+            for (var propKey in removedKeys) if (removedKeys[propKey]) {
+                var nextProp = obj[propKey];
+                if (void 0 !== nextProp) {
+                    var attributeConfig = validAttributes[propKey];
+                    if (attributeConfig) {
+                        if ("function" == typeof nextProp && (nextProp = !0), void 0 === nextProp && (nextProp = null), 
+                        "object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+                            var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
+                            updatePayload[propKey] = nextValue;
+                        }
+                        removedKeys[propKey] = !1, removedKeyCount--;
+                    }
+                }
+            }
+        }
+    }
+    function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
+        var i, minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
+        for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
+        for (;i < prevArray.length; i++) updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
+        for (;i < nextArray.length; i++) updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
+        return updatePayload;
+    }
+    function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
+        return updatePayload || prevProp !== nextProp ? prevProp && nextProp ? Array.isArray(prevProp) || Array.isArray(nextProp) ? Array.isArray(prevProp) && Array.isArray(nextProp) ? diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes) : Array.isArray(prevProp) ? diffProperties(updatePayload, flattenStyle(prevProp), resolveObject(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), flattenStyle(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), resolveObject(nextProp), validAttributes) : nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload : updatePayload;
+    }
+    function addNestedProperty(updatePayload, nextProp, validAttributes) {
+        if (!nextProp) return updatePayload;
+        if (!Array.isArray(nextProp)) return addProperties(updatePayload, resolveObject(nextProp), validAttributes);
+        for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
+        return updatePayload;
+    }
+    function clearNestedProperty(updatePayload, prevProp, validAttributes) {
+        if (!prevProp) return updatePayload;
+        if (!Array.isArray(prevProp)) return clearProperties(updatePayload, resolveObject(prevProp), validAttributes);
+        for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
+        return updatePayload;
+    }
+    function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
+        var attributeConfig, nextProp, prevProp;
+        for (var propKey in nextProps) if (attributeConfig = validAttributes[propKey]) if (prevProp = prevProps[propKey], 
+        nextProp = nextProps[propKey], "function" == typeof nextProp && (nextProp = !0, 
+        "function" == typeof prevProp && (prevProp = !0)), void 0 === nextProp && (nextProp = null, 
+        void 0 === prevProp && (prevProp = null)), removedKeys && (removedKeys[propKey] = !1), 
+        updatePayload && void 0 !== updatePayload[propKey]) {
+            if ("object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+                var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
+                updatePayload[propKey] = nextValue;
+            }
+        } else if (prevProp !== nextProp) if ("object" != typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp); else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
+            var shouldUpdate = void 0 === prevProp || ("function" == typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));
+            shouldUpdate && (nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, 
+            (updatePayload || (updatePayload = {}))[propKey] = nextValue);
+        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 
+        removedKeyCount > 0 && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), 
+        removedKeys = null);
+        for (propKey in prevProps) void 0 === nextProps[propKey] && (attributeConfig = validAttributes[propKey]) && (updatePayload && void 0 !== updatePayload[propKey] || void 0 !== (prevProp = prevProps[propKey]) && ("object" != typeof attributeConfig || "function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey] = null, 
+        removedKeys || (removedKeys = {}), removedKeys[propKey] || (removedKeys[propKey] = !0, 
+        removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig)));
+        return updatePayload;
+    }
+    function addProperties(updatePayload, props, validAttributes) {
+        return diffProperties(updatePayload, emptyObject$2, props, validAttributes);
+    }
+    function clearProperties(updatePayload, prevProps, validAttributes) {
+        return diffProperties(updatePayload, prevProps, emptyObject$2, validAttributes);
+    }
+    var ReactNativeAttributePayload = {
+        create: function(props, validAttributes) {
+            return addProperties(null, props, validAttributes);
+        },
+        diff: function(prevProps, nextProps, validAttributes) {
+            return diffProperties(null, prevProps, nextProps, validAttributes);
+        }
+    }, ReactNativeAttributePayload_1 = ReactNativeAttributePayload;
+    function mountSafeCallback$1(context, callback) {
+        return function() {
+            if (callback) {
+                if ("boolean" == typeof context.__isMounted) {
+                    if (!context.__isMounted) return;
+                } else if ("function" == typeof context.isMounted && !context.isMounted()) return;
+                return callback.apply(context, arguments);
             }
         };
-    });
-};
-
-getInspectorDataForViewTag = function(viewTag) {
-    var component = ReactNativeComponentTree_1.getClosestInstanceFromNode(viewTag);
-    if (!component) return {
-        hierarchy: [],
-        props: emptyObject,
-        selection: null,
-        source: null
-    };
-    var componentHierarchy = getOwnerHierarchy(component), instance = lastNotNativeInstance(componentHierarchy), hierarchy = createHierarchy(componentHierarchy), props = getHostProps(instance), source = instance._currentElement && instance._currentElement._source;
-    return {
-        hierarchy: hierarchy,
-        props: props,
-        selection: componentHierarchy.indexOf(instance),
-        source: source
-    };
-};
-
-var ReactNativeStackInspector = {
-    getInspectorDataForViewTag: getInspectorDataForViewTag
-}, findNumericNodeHandleStack = function(componentOrHandle) {
-    var nodeHandle = findNodeHandle_1(componentOrHandle);
-    return null == nodeHandle || "number" == typeof nodeHandle ? nodeHandle : nodeHandle.getHostNode();
-};
-
-function _classCallCheck$2(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-var objects = {}, uniqueID = 1, emptyObject$3 = {}, ReactNativePropRegistry = function() {
-    function ReactNativePropRegistry() {
-        _classCallCheck$2(this, ReactNativePropRegistry);
     }
-    return ReactNativePropRegistry.register = function(object) {
-        var id = ++uniqueID;
-        return Object.freeze(object), objects[id] = object, id;
-    }, ReactNativePropRegistry.getByID = function(id) {
-        if (!id) return emptyObject$3;
-        var object = objects[id];
-        return object || (console.warn("Invalid style with id `" + id + "`. Skipping ..."), 
-        emptyObject$3);
-    }, ReactNativePropRegistry;
-}(), ReactNativePropRegistry_1 = ReactNativePropRegistry, emptyObject$2 = {}, removedKeys = null, removedKeyCount = 0;
-
-function defaultDiffer(prevProp, nextProp) {
-    return "object" != typeof nextProp || null === nextProp || deepDiffer(prevProp, nextProp);
-}
-
-function resolveObject(idOrObject) {
-    return "number" == typeof idOrObject ? ReactNativePropRegistry_1.getByID(idOrObject) : idOrObject;
-}
-
-function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
-    if (Array.isArray(node)) for (var i = node.length; i-- && removedKeyCount > 0; ) restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes); else if (node && removedKeyCount > 0) {
-        var obj = resolveObject(node);
-        for (var propKey in removedKeys) if (removedKeys[propKey]) {
-            var nextProp = obj[propKey];
-            if (void 0 !== nextProp) {
-                var attributeConfig = validAttributes[propKey];
-                if (attributeConfig) {
-                    if ("function" == typeof nextProp && (nextProp = !0), void 0 === nextProp && (nextProp = null), 
-                    "object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-                        var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
-                        updatePayload[propKey] = nextValue;
-                    }
-                    removedKeys[propKey] = !1, removedKeyCount--;
+    function throwOnStylesProp(component, props) {
+        if (void 0 !== props.styles) {
+            var owner = component._owner || null, name = component.constructor.displayName, msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
+            throw owner && owner.constructor && owner.constructor.displayName && (msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component."), 
+            new Error(msg);
+        }
+    }
+    function warnForStyleProps(props, validAttributes) {
+        for (var key in validAttributes.style) validAttributes[key] || void 0 === props[key] || console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
+    }
+    var NativeMethodsMixinUtils = {
+        mountSafeCallback: mountSafeCallback$1,
+        throwOnStylesProp: throwOnStylesProp,
+        warnForStyleProps: warnForStyleProps
+    };
+    function _classCallCheck$1(instance, Constructor) {
+        if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+        if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        return !call || "object" != typeof call && "function" != typeof call ? self : call;
+    }
+    function _inherits(subClass, superClass) {
+        if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: !1,
+                writable: !0,
+                configurable: !0
+            }
+        }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
+    }
+    var ReactNativeFeatureFlags$1 = require("ReactNativeFeatureFlags"), mountSafeCallback = NativeMethodsMixinUtils.mountSafeCallback, findNumericNodeHandle = ReactNativeFeatureFlags$1.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack, ReactNativeComponent = function(_React$Component) {
+        _inherits(ReactNativeComponent, _React$Component);
+        function ReactNativeComponent() {
+            return _classCallCheck$1(this, ReactNativeComponent), _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
+        }
+        return ReactNativeComponent.prototype.blur = function() {
+            TextInputState.blurTextInput(findNumericNodeHandle(this));
+        }, ReactNativeComponent.prototype.focus = function() {
+            TextInputState.focusTextInput(findNumericNodeHandle(this));
+        }, ReactNativeComponent.prototype.measure = function(callback) {
+            UIManager.measure(findNumericNodeHandle(this), mountSafeCallback(this, callback));
+        }, ReactNativeComponent.prototype.measureInWindow = function(callback) {
+            UIManager.measureInWindow(findNumericNodeHandle(this), mountSafeCallback(this, callback));
+        }, ReactNativeComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
+            UIManager.measureLayout(findNumericNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
+        }, ReactNativeComponent.prototype.setNativeProps = function(nativeProps) {
+            injectedSetNativeProps(this, nativeProps);
+        }, ReactNativeComponent;
+    }(React.Component);
+    function setNativePropsFiber(componentOrHandle, nativeProps) {
+        var maybeInstance = void 0;
+        try {
+            maybeInstance = findNodeHandle_1(componentOrHandle);
+        } catch (error) {}
+        if (null != maybeInstance) {
+            var viewConfig = maybeInstance.viewConfig, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    function setNativePropsStack(componentOrHandle, nativeProps) {
+        var maybeInstance = findNodeHandle_1(componentOrHandle);
+        if (null != maybeInstance) {
+            var viewConfig = void 0;
+            if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
+                for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
+                viewConfig = maybeInstance.viewConfig;
+            }
+            var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    var injectedSetNativeProps = void 0;
+    injectedSetNativeProps = ReactNativeFeatureFlags$1.useFiber ? setNativePropsFiber : setNativePropsStack;
+    var ReactNativeComponent_1 = ReactNativeComponent, ReactNativeFeatureFlags$2 = require("ReactNativeFeatureFlags"), mountSafeCallback$2 = NativeMethodsMixinUtils.mountSafeCallback, throwOnStylesProp$1 = NativeMethodsMixinUtils.throwOnStylesProp, warnForStyleProps$1 = NativeMethodsMixinUtils.warnForStyleProps, findNumericNodeHandle$1 = ReactNativeFeatureFlags$2.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack, NativeMethodsMixin = {
+        measure: function(callback) {
+            UIManager.measure(findNumericNodeHandle$1(this), mountSafeCallback$2(this, callback));
+        },
+        measureInWindow: function(callback) {
+            UIManager.measureInWindow(findNumericNodeHandle$1(this), mountSafeCallback$2(this, callback));
+        },
+        measureLayout: function(relativeToNativeNode, onSuccess, onFail) {
+            UIManager.measureLayout(findNumericNodeHandle$1(this), relativeToNativeNode, mountSafeCallback$2(this, onFail), mountSafeCallback$2(this, onSuccess));
+        },
+        setNativeProps: function(nativeProps) {
+            injectedSetNativeProps$1(this, nativeProps);
+        },
+        focus: function() {
+            TextInputState.focusTextInput(findNumericNodeHandle$1(this));
+        },
+        blur: function() {
+            TextInputState.blurTextInput(findNumericNodeHandle$1(this));
+        }
+    };
+    function setNativePropsFiber$1(componentOrHandle, nativeProps) {
+        var maybeInstance = void 0;
+        try {
+            maybeInstance = findNodeHandle_1(componentOrHandle);
+        } catch (error) {}
+        if (null != maybeInstance) {
+            var viewConfig = maybeInstance.viewConfig;
+            warnForStyleProps$1(nativeProps, viewConfig.validAttributes);
+            var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    function setNativePropsStack$1(componentOrHandle, nativeProps) {
+        var maybeInstance = findNodeHandle_1(componentOrHandle);
+        if (null != maybeInstance) {
+            var viewConfig = void 0;
+            if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
+                for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
+                viewConfig = maybeInstance.viewConfig;
+            }
+            var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID;
+            warnForStyleProps$1(nativeProps, viewConfig.validAttributes);
+            var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
+            UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
+        }
+    }
+    var injectedSetNativeProps$1 = void 0;
+    injectedSetNativeProps$1 = ReactNativeFeatureFlags$2.useFiber ? setNativePropsFiber$1 : setNativePropsStack$1;
+    var NativeMethodsMixin_DEV = NativeMethodsMixin;
+    invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps, "Do not override existing functions."), 
+    NativeMethodsMixin_DEV.componentWillMount = function() {
+        throwOnStylesProp$1(this, this.props);
+    }, NativeMethodsMixin_DEV.componentWillReceiveProps = function(newProps) {
+        throwOnStylesProp$1(this, newProps);
+    };
+    var NativeMethodsMixin_1 = NativeMethodsMixin, TouchHistoryMath = {
+        centroidDimension: function(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
+            var touchBank = touchHistory.touchBank, total = 0, count = 0, oneTouchData = 1 === touchHistory.numberActiveTouches ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
+            if (null !== oneTouchData) oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter && (total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY, 
+            count = 1); else for (var i = 0; i < touchBank.length; i++) {
+                var touchTrack = touchBank[i];
+                if (null !== touchTrack && void 0 !== touchTrack && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
+                    var toAdd;
+                    toAdd = ofCurrent && isXAxis ? touchTrack.currentPageX : ofCurrent && !isXAxis ? touchTrack.currentPageY : !ofCurrent && isXAxis ? touchTrack.previousPageX : touchTrack.previousPageY, 
+                    total += toAdd, count++;
                 }
             }
-        }
+            return count > 0 ? total / count : TouchHistoryMath.noCentroid;
+        },
+        currentCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !0);
+        },
+        currentCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !0);
+        },
+        previousCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !1);
+        },
+        previousCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
+            return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !1);
+        },
+        currentCentroidX: function(touchHistory) {
+            return TouchHistoryMath.centroidDimension(touchHistory, 0, !0, !0);
+        },
+        currentCentroidY: function(touchHistory) {
+            return TouchHistoryMath.centroidDimension(touchHistory, 0, !1, !0);
+        },
+        noCentroid: -1
+    }, TouchHistoryMath_1 = TouchHistoryMath;
+    function escape(key) {
+        var escaperLookup = {
+            "=": "=0",
+            ":": "=2"
+        };
+        return "$" + ("" + key).replace(/[=:]/g, function(match) {
+            return escaperLookup[match];
+        });
     }
-}
-
-function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
-    var i, minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
-    for (i = 0; i < minLength; i++) updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
-    for (;i < prevArray.length; i++) updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
-    for (;i < nextArray.length; i++) updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
-    return updatePayload;
-}
-
-function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
-    return updatePayload || prevProp !== nextProp ? prevProp && nextProp ? Array.isArray(prevProp) || Array.isArray(nextProp) ? Array.isArray(prevProp) && Array.isArray(nextProp) ? diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes) : Array.isArray(prevProp) ? diffProperties(updatePayload, flattenStyle(prevProp), resolveObject(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), flattenStyle(nextProp), validAttributes) : diffProperties(updatePayload, resolveObject(prevProp), resolveObject(nextProp), validAttributes) : nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload : updatePayload;
-}
-
-function addNestedProperty(updatePayload, nextProp, validAttributes) {
-    if (!nextProp) return updatePayload;
-    if (!Array.isArray(nextProp)) return addProperties(updatePayload, resolveObject(nextProp), validAttributes);
-    for (var i = 0; i < nextProp.length; i++) updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
-    return updatePayload;
-}
-
-function clearNestedProperty(updatePayload, prevProp, validAttributes) {
-    if (!prevProp) return updatePayload;
-    if (!Array.isArray(prevProp)) return clearProperties(updatePayload, resolveObject(prevProp), validAttributes);
-    for (var i = 0; i < prevProp.length; i++) updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
-    return updatePayload;
-}
-
-function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
-    var attributeConfig, nextProp, prevProp;
-    for (var propKey in nextProps) if (attributeConfig = validAttributes[propKey]) if (prevProp = prevProps[propKey], 
-    nextProp = nextProps[propKey], "function" == typeof nextProp && (nextProp = !0, 
-    "function" == typeof prevProp && (prevProp = !0)), void 0 === nextProp && (nextProp = null, 
-    void 0 === prevProp && (prevProp = null)), removedKeys && (removedKeys[propKey] = !1), 
-    updatePayload && void 0 !== updatePayload[propKey]) {
-        if ("object" != typeof attributeConfig) updatePayload[propKey] = nextProp; else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-            var nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp;
-            updatePayload[propKey] = nextValue;
-        }
-    } else if (prevProp !== nextProp) if ("object" != typeof attributeConfig) defaultDiffer(prevProp, nextProp) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp); else if ("function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process) {
-        var shouldUpdate = void 0 === prevProp || ("function" == typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));
-        shouldUpdate && (nextValue = "function" == typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, 
-        (updatePayload || (updatePayload = {}))[propKey] = nextValue);
-    } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 
-    removedKeyCount > 0 && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), 
-    removedKeys = null);
-    for (propKey in prevProps) void 0 === nextProps[propKey] && (attributeConfig = validAttributes[propKey]) && (updatePayload && void 0 !== updatePayload[propKey] || void 0 !== (prevProp = prevProps[propKey]) && ("object" != typeof attributeConfig || "function" == typeof attributeConfig.diff || "function" == typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[propKey] = null, 
-    removedKeys || (removedKeys = {}), removedKeys[propKey] || (removedKeys[propKey] = !0, 
-    removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig)));
-    return updatePayload;
-}
-
-function addProperties(updatePayload, props, validAttributes) {
-    return diffProperties(updatePayload, emptyObject$2, props, validAttributes);
-}
-
-function clearProperties(updatePayload, prevProps, validAttributes) {
-    return diffProperties(updatePayload, prevProps, emptyObject$2, validAttributes);
-}
-
-var ReactNativeAttributePayload = {
-    create: function(props, validAttributes) {
-        return addProperties(null, props, validAttributes);
-    },
-    diff: function(prevProps, nextProps, validAttributes) {
-        return diffProperties(null, prevProps, nextProps, validAttributes);
-    }
-}, ReactNativeAttributePayload_1 = ReactNativeAttributePayload;
-
-function mountSafeCallback$1(context, callback) {
-    return function() {
-        if (callback) {
-            if ("boolean" == typeof context.__isMounted) {
-                if (!context.__isMounted) return;
-            } else if ("function" == typeof context.isMounted && !context.isMounted()) return;
-            return callback.apply(context, arguments);
-        }
+    var unescapeInDev = emptyFunction;
+    unescapeInDev = function(key) {
+        var unescapeRegex = /(=0|=2)/g, unescaperLookup = {
+            "=0": "=",
+            "=2": ":"
+        };
+        return ("" + ("." === key[0] && "$" === key[1] ? key.substring(2) : key.substring(1))).replace(unescapeRegex, function(match) {
+            return unescaperLookup[match];
+        });
     };
-}
-
-function throwOnStylesProp(component, props) {
-    if (void 0 !== props.styles) {
-        var owner = component._owner || null, name = component.constructor.displayName, msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";
-        throw owner && owner.constructor && owner.constructor.displayName && (msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component."), 
-        new Error(msg);
+    var KeyEscapeUtils = {
+        escape: escape,
+        unescapeInDev: unescapeInDev
+    }, KeyEscapeUtils_1 = KeyEscapeUtils, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, getCurrentStackAddendum$1 = ReactGlobalSharedState_1.ReactComponentTreeHook.getCurrentStackAddendum, SEPARATOR = ".", SUBSEPARATOR = ":", didWarnAboutMaps = !1;
+    function getComponentKey(component, index) {
+        return component && "object" == typeof component && null != component.key ? KeyEscapeUtils_1.escape(component.key) : index.toString(36);
     }
-}
-
-function warnForStyleProps(props, validAttributes) {
-    for (var key in validAttributes.style) validAttributes[key] || void 0 === props[key] || console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
-}
-
-var NativeMethodsMixinUtils = {
-    mountSafeCallback: mountSafeCallback$1,
-    throwOnStylesProp: throwOnStylesProp,
-    warnForStyleProps: warnForStyleProps
-};
-
-function _classCallCheck$1(instance, Constructor) {
-    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
-}
-
-function _possibleConstructorReturn(self, call) {
-    if (!self) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-    return !call || "object" != typeof call && "function" != typeof call ? self : call;
-}
-
-function _inherits(subClass, superClass) {
-    if ("function" != typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
-    subClass.prototype = Object.create(superClass && superClass.prototype, {
-        constructor: {
-            value: subClass,
-            enumerable: !1,
-            writable: !0,
-            configurable: !0
-        }
-    }), superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
-}
-
-var ReactNativeFeatureFlags$1 = require("ReactNativeFeatureFlags"), mountSafeCallback = NativeMethodsMixinUtils.mountSafeCallback, findNumericNodeHandle = ReactNativeFeatureFlags$1.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack, ReactNativeComponent = function(_React$Component) {
-    _inherits(ReactNativeComponent, _React$Component);
-    function ReactNativeComponent() {
-        return _classCallCheck$1(this, ReactNativeComponent), _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
-    }
-    return ReactNativeComponent.prototype.blur = function() {
-        TextInputState.blurTextInput(findNumericNodeHandle(this));
-    }, ReactNativeComponent.prototype.focus = function() {
-        TextInputState.focusTextInput(findNumericNodeHandle(this));
-    }, ReactNativeComponent.prototype.measure = function(callback) {
-        UIManager.measure(findNumericNodeHandle(this), mountSafeCallback(this, callback));
-    }, ReactNativeComponent.prototype.measureInWindow = function(callback) {
-        UIManager.measureInWindow(findNumericNodeHandle(this), mountSafeCallback(this, callback));
-    }, ReactNativeComponent.prototype.measureLayout = function(relativeToNativeNode, onSuccess, onFail) {
-        UIManager.measureLayout(findNumericNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
-    }, ReactNativeComponent.prototype.setNativeProps = function(nativeProps) {
-        injectedSetNativeProps(this, nativeProps);
-    }, ReactNativeComponent;
-}(React.Component);
-
-function setNativePropsFiber(componentOrHandle, nativeProps) {
-    var maybeInstance = void 0;
-    try {
-        maybeInstance = findNodeHandle_1(componentOrHandle);
-    } catch (error) {}
-    if (null != maybeInstance) {
-        var viewConfig = maybeInstance.viewConfig, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-function setNativePropsStack(componentOrHandle, nativeProps) {
-    var maybeInstance = findNodeHandle_1(componentOrHandle);
-    if (null != maybeInstance) {
-        var viewConfig = void 0;
-        if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
-            for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
-            viewConfig = maybeInstance.viewConfig;
-        }
-        var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID, updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-var injectedSetNativeProps = void 0;
-
-injectedSetNativeProps = ReactNativeFeatureFlags$1.useFiber ? setNativePropsFiber : setNativePropsStack;
-
-var ReactNativeComponent_1 = ReactNativeComponent, ReactNativeFeatureFlags$2 = require("ReactNativeFeatureFlags"), mountSafeCallback$2 = NativeMethodsMixinUtils.mountSafeCallback, throwOnStylesProp$1 = NativeMethodsMixinUtils.throwOnStylesProp, warnForStyleProps$1 = NativeMethodsMixinUtils.warnForStyleProps, findNumericNodeHandle$1 = ReactNativeFeatureFlags$2.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack, NativeMethodsMixin = {
-    measure: function(callback) {
-        UIManager.measure(findNumericNodeHandle$1(this), mountSafeCallback$2(this, callback));
-    },
-    measureInWindow: function(callback) {
-        UIManager.measureInWindow(findNumericNodeHandle$1(this), mountSafeCallback$2(this, callback));
-    },
-    measureLayout: function(relativeToNativeNode, onSuccess, onFail) {
-        UIManager.measureLayout(findNumericNodeHandle$1(this), relativeToNativeNode, mountSafeCallback$2(this, onFail), mountSafeCallback$2(this, onSuccess));
-    },
-    setNativeProps: function(nativeProps) {
-        injectedSetNativeProps$1(this, nativeProps);
-    },
-    focus: function() {
-        TextInputState.focusTextInput(findNumericNodeHandle$1(this));
-    },
-    blur: function() {
-        TextInputState.blurTextInput(findNumericNodeHandle$1(this));
-    }
-};
-
-function setNativePropsFiber$1(componentOrHandle, nativeProps) {
-    var maybeInstance = void 0;
-    try {
-        maybeInstance = findNodeHandle_1(componentOrHandle);
-    } catch (error) {}
-    if (null != maybeInstance) {
-        var viewConfig = maybeInstance.viewConfig;
-        warnForStyleProps$1(nativeProps, viewConfig.validAttributes);
-        var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-function setNativePropsStack$1(componentOrHandle, nativeProps) {
-    var maybeInstance = findNodeHandle_1(componentOrHandle);
-    if (null != maybeInstance) {
-        var viewConfig = void 0;
-        if (void 0 !== maybeInstance.viewConfig) viewConfig = maybeInstance.viewConfig; else if (void 0 !== maybeInstance._instance && void 0 !== maybeInstance._instance.viewConfig) viewConfig = maybeInstance._instance.viewConfig; else {
-            for (;void 0 !== maybeInstance._renderedComponent; ) maybeInstance = maybeInstance._renderedComponent;
-            viewConfig = maybeInstance.viewConfig;
-        }
-        var tag = "function" == typeof maybeInstance.getHostNode ? maybeInstance.getHostNode() : maybeInstance._rootNodeID;
-        warnForStyleProps$1(nativeProps, viewConfig.validAttributes);
-        var updatePayload = ReactNativeAttributePayload_1.create(nativeProps, viewConfig.validAttributes);
-        UIManager.updateView(tag, viewConfig.uiViewClassName, updatePayload);
-    }
-}
-
-var injectedSetNativeProps$1 = void 0;
-
-injectedSetNativeProps$1 = ReactNativeFeatureFlags$2.useFiber ? setNativePropsFiber$1 : setNativePropsStack$1;
-
-var NativeMethodsMixin_DEV = NativeMethodsMixin;
-
-invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps, "Do not override existing functions."), 
-NativeMethodsMixin_DEV.componentWillMount = function() {
-    throwOnStylesProp$1(this, this.props);
-}, NativeMethodsMixin_DEV.componentWillReceiveProps = function(newProps) {
-    throwOnStylesProp$1(this, newProps);
-};
-
-var NativeMethodsMixin_1 = NativeMethodsMixin, TouchHistoryMath = {
-    centroidDimension: function(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
-        var touchBank = touchHistory.touchBank, total = 0, count = 0, oneTouchData = 1 === touchHistory.numberActiveTouches ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;
-        if (null !== oneTouchData) oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter && (total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY, 
-        count = 1); else for (var i = 0; i < touchBank.length; i++) {
-            var touchTrack = touchBank[i];
-            if (null !== touchTrack && void 0 !== touchTrack && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
-                var toAdd;
-                toAdd = ofCurrent && isXAxis ? touchTrack.currentPageX : ofCurrent && !isXAxis ? touchTrack.currentPageY : !ofCurrent && isXAxis ? touchTrack.previousPageX : touchTrack.previousPageY, 
-                total += toAdd, count++;
+    function traverseStackChildrenImpl(children, nameSoFar, callback, traverseContext) {
+        var type = typeof children;
+        if ("undefined" !== type && "boolean" !== type || (children = null), null === children || "string" === type || "number" === type || "object" === type && children.$$typeof === REACT_ELEMENT_TYPE) return callback(traverseContext, children, "" === nameSoFar ? SEPARATOR + getComponentKey(children, 0) : nameSoFar), 
+        1;
+        var child, nextName, subtreeCount = 0, nextNamePrefix = "" === nameSoFar ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+        if (Array.isArray(children)) for (var i = 0; i < children.length; i++) child = children[i], 
+        nextName = nextNamePrefix + getComponentKey(child, i), subtreeCount += traverseStackChildrenImpl(child, nextName, callback, traverseContext); else {
+            var iteratorFn = ITERATOR_SYMBOL && children[ITERATOR_SYMBOL] || children[FAUX_ITERATOR_SYMBOL];
+            if ("function" == typeof iteratorFn) {
+                iteratorFn === children.entries && (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", getCurrentStackAddendum$1()), 
+                didWarnAboutMaps = !0);
+                for (var step, iterator = iteratorFn.call(children), ii = 0; !(step = iterator.next()).done; ) child = step.value, 
+                nextName = nextNamePrefix + getComponentKey(child, ii++), subtreeCount += traverseStackChildrenImpl(child, nextName, callback, traverseContext);
+            } else if ("object" === type) {
+                var addendum = "";
+                addendum = " If you meant to render a collection of children, use an array " + "instead." + getCurrentStackAddendum$1();
+                var childrenString = "" + children;
+                invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString, addendum);
             }
         }
-        return count > 0 ? total / count : TouchHistoryMath.noCentroid;
-    },
-    currentCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !0);
-    },
-    currentCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !0);
-    },
-    previousCentroidXOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !0, !1);
-    },
-    previousCentroidYOfTouchesChangedAfter: function(touchHistory, touchesChangedAfter) {
-        return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, !1, !1);
-    },
-    currentCentroidX: function(touchHistory) {
-        return TouchHistoryMath.centroidDimension(touchHistory, 0, !0, !0);
-    },
-    currentCentroidY: function(touchHistory) {
-        return TouchHistoryMath.centroidDimension(touchHistory, 0, !1, !0);
-    },
-    noCentroid: -1
-}, TouchHistoryMath_1 = TouchHistoryMath;
-
-function escape(key) {
-    var escaperLookup = {
-        "=": "=0",
-        ":": "=2"
-    };
-    return "$" + ("" + key).replace(/[=:]/g, function(match) {
-        return escaperLookup[match];
-    });
-}
-
-var unescapeInDev = emptyFunction;
-
-unescapeInDev = function(key) {
-    var unescapeRegex = /(=0|=2)/g, unescaperLookup = {
-        "=0": "=",
-        "=2": ":"
-    };
-    return ("" + ("." === key[0] && "$" === key[1] ? key.substring(2) : key.substring(1))).replace(unescapeRegex, function(match) {
-        return unescaperLookup[match];
-    });
-};
-
-var KeyEscapeUtils = {
-    escape: escape,
-    unescapeInDev: unescapeInDev
-}, KeyEscapeUtils_1 = KeyEscapeUtils, ITERATOR_SYMBOL = "function" == typeof Symbol && Symbol.iterator, FAUX_ITERATOR_SYMBOL = "@@iterator", REACT_ELEMENT_TYPE = "function" == typeof Symbol && Symbol.for && Symbol.for("react.element") || 60103, getCurrentStackAddendum = ReactGlobalSharedState_1.ReactComponentTreeHook.getCurrentStackAddendum, SEPARATOR = ".", SUBSEPARATOR = ":", didWarnAboutMaps = !1;
-
-function getComponentKey(component, index) {
-    return component && "object" == typeof component && null != component.key ? KeyEscapeUtils_1.escape(component.key) : index.toString(36);
-}
-
-function traverseStackChildrenImpl(children, nameSoFar, callback, traverseContext) {
-    var type = typeof children;
-    if ("undefined" !== type && "boolean" !== type || (children = null), null === children || "string" === type || "number" === type || "object" === type && children.$$typeof === REACT_ELEMENT_TYPE) return callback(traverseContext, children, "" === nameSoFar ? SEPARATOR + getComponentKey(children, 0) : nameSoFar), 
-    1;
-    var child, nextName, subtreeCount = 0, nextNamePrefix = "" === nameSoFar ? SEPARATOR : nameSoFar + SUBSEPARATOR;
-    if (Array.isArray(children)) for (var i = 0; i < children.length; i++) child = children[i], 
-    nextName = nextNamePrefix + getComponentKey(child, i), subtreeCount += traverseStackChildrenImpl(child, nextName, callback, traverseContext); else {
-        var iteratorFn = ITERATOR_SYMBOL && children[ITERATOR_SYMBOL] || children[FAUX_ITERATOR_SYMBOL];
-        if ("function" == typeof iteratorFn) {
-            iteratorFn === children.entries && (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", getCurrentStackAddendum()), 
-            didWarnAboutMaps = !0);
-            for (var step, iterator = iteratorFn.call(children), ii = 0; !(step = iterator.next()).done; ) child = step.value, 
-            nextName = nextNamePrefix + getComponentKey(child, ii++), subtreeCount += traverseStackChildrenImpl(child, nextName, callback, traverseContext);
-        } else if ("object" === type) {
-            var addendum = "";
-            addendum = " If you meant to render a collection of children, use an array " + "instead." + getCurrentStackAddendum();
-            var childrenString = "" + children;
-            invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[object Object]" === childrenString ? "object with keys {" + Object.keys(children).join(", ") + "}" : childrenString, addendum);
-        }
+        return subtreeCount;
     }
-    return subtreeCount;
-}
-
-function traverseStackChildren(children, callback, traverseContext) {
-    return null == children ? 0 : traverseStackChildrenImpl(children, "", callback, traverseContext);
-}
-
-var traverseStackChildren_1 = traverseStackChildren, ReactComponentTreeHook$2;
-
-"undefined" != typeof process && process.env && "development" == "test" && (ReactComponentTreeHook$2 = ReactGlobalSharedState_1.ReactComponentTreeHook);
-
-function instantiateChild(childInstances, child, name, selfDebugID) {
-    var keyUnique = void 0 === childInstances[name];
-    ReactComponentTreeHook$2 || (ReactComponentTreeHook$2 = ReactGlobalSharedState_1.ReactComponentTreeHook), 
-    keyUnique || warning(!1, "flattenChildren(...):" + "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", KeyEscapeUtils_1.unescapeInDev(name), ReactComponentTreeHook$2.getStackAddendumByID(selfDebugID)), 
-    null != child && keyUnique && (childInstances[name] = instantiateReactComponent_1(child, !0));
-}
-
-var ReactChildReconciler = {
-    instantiateChildren: function(nestedChildNodes, transaction, context, selfDebugID) {
-        if (null == nestedChildNodes) return null;
-        var childInstances = {};
-        return traverseStackChildren_1(nestedChildNodes, function(childInsts, child, name) {
-            return instantiateChild(childInsts, child, name, selfDebugID);
-        }, childInstances), childInstances;
-    },
-    updateChildren: function(prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID) {
-        if (nextChildren || prevChildren) {
-            var name, prevChild;
-            for (name in nextChildren) if (nextChildren.hasOwnProperty(name)) {
-                prevChild = prevChildren && prevChildren[name];
-                var prevElement = prevChild && prevChild._currentElement, nextElement = nextChildren[name];
-                if (null != prevChild && shouldUpdateReactComponent_1(prevElement, nextElement)) ReactReconciler_1.receiveComponent(prevChild, nextElement, transaction, context), 
-                nextChildren[name] = prevChild; else {
-                    var nextChildInstance = instantiateReactComponent_1(nextElement, !0);
-                    nextChildren[name] = nextChildInstance;
-                    var nextChildMountImage = ReactReconciler_1.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
-                    mountImages.push(nextChildMountImage), prevChild && (removedNodes[name] = ReactReconciler_1.getHostNode(prevChild), 
-                    ReactReconciler_1.unmountComponent(prevChild, !1, !1));
-                }
-            }
-            for (name in prevChildren) !prevChildren.hasOwnProperty(name) || nextChildren && nextChildren.hasOwnProperty(name) || (prevChild = prevChildren[name], 
-            removedNodes[name] = ReactReconciler_1.getHostNode(prevChild), ReactReconciler_1.unmountComponent(prevChild, !1, !1));
-        }
-    },
-    unmountChildren: function(renderedChildren, safely, skipLifecycle) {
-        for (var name in renderedChildren) if (renderedChildren.hasOwnProperty(name)) {
-            var renderedChild = renderedChildren[name];
-            ReactReconciler_1.unmountComponent(renderedChild, safely, skipLifecycle);
-        }
+    function traverseStackChildren(children, callback, traverseContext) {
+        return null == children ? 0 : traverseStackChildrenImpl(children, "", callback, traverseContext);
     }
-}, ReactChildReconciler_1 = ReactChildReconciler, ReactComponentTreeHook$3;
-
-"undefined" != typeof process && process.env && "development" == "test" && (ReactComponentTreeHook$3 = ReactGlobalSharedState_1.ReactComponentTreeHook);
-
-function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
-    if (traverseContext && "object" == typeof traverseContext) {
-        var result = traverseContext, keyUnique = void 0 === result[name];
+    var ReactComponentTreeHook$3, traverseStackChildren_1 = traverseStackChildren;
+    "undefined" != typeof process && process.env && "development" == "test" && (ReactComponentTreeHook$3 = ReactGlobalSharedState_1.ReactComponentTreeHook);
+    function instantiateChild(childInstances, child, name, selfDebugID) {
+        var keyUnique = void 0 === childInstances[name];
         ReactComponentTreeHook$3 || (ReactComponentTreeHook$3 = ReactGlobalSharedState_1.ReactComponentTreeHook), 
-        keyUnique || warning(!1, "flattenChildren(...): 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", KeyEscapeUtils_1.unescapeInDev(name), ReactComponentTreeHook$3.getStackAddendumByID(selfDebugID)), 
-        keyUnique && null != child && (result[name] = child);
+        keyUnique || warning(!1, "flattenChildren(...): " + "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", KeyEscapeUtils_1.unescapeInDev(name), ReactComponentTreeHook$3.getStackAddendumByID(selfDebugID)), 
+        null != child && keyUnique && (childInstances[name] = instantiateReactComponent_1(child, !0));
     }
-}
-
-function flattenStackChildren(children, selfDebugID) {
-    if (null == children) return children;
-    var result = {};
-    return traverseStackChildren_1(children, function(traverseContext, child, name) {
-        return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
-    }, result), result;
-}
-
-var flattenStackChildren_1 = flattenStackChildren, ReactCurrentOwner$3 = ReactGlobalSharedState_1.ReactCurrentOwner;
-
-function makeInsertMarkup(markup, afterNode, toIndex) {
-    return {
-        type: "INSERT_MARKUP",
-        content: markup,
-        fromIndex: null,
-        fromNode: null,
-        toIndex: toIndex,
-        afterNode: afterNode
-    };
-}
-
-function makeMove(child, afterNode, toIndex) {
-    return {
-        type: "MOVE_EXISTING",
-        content: null,
-        fromIndex: child._mountIndex,
-        fromNode: ReactReconciler_1.getHostNode(child),
-        toIndex: toIndex,
-        afterNode: afterNode
-    };
-}
-
-function makeRemove(child, node) {
-    return {
-        type: "REMOVE_NODE",
-        content: null,
-        fromIndex: child._mountIndex,
-        fromNode: node,
-        toIndex: null,
-        afterNode: null
-    };
-}
-
-function makeSetMarkup(markup) {
-    return {
-        type: "SET_MARKUP",
-        content: markup,
-        fromIndex: null,
-        fromNode: null,
-        toIndex: null,
-        afterNode: null
-    };
-}
-
-function makeTextContent(textContent) {
-    return {
-        type: "TEXT_CONTENT",
-        content: textContent,
-        fromIndex: null,
-        fromNode: null,
-        toIndex: null,
-        afterNode: null
-    };
-}
-
-function enqueue(queue, update) {
-    return update && (queue = queue || [], queue.push(update)), queue;
-}
-
-function processQueue(inst, updateQueue) {
-    ReactComponentEnvironment_1.processChildrenUpdates(inst, updateQueue);
-}
-
-var setChildrenForInstrumentation = emptyFunction, getDebugID = function(inst) {
-    if (!inst._debugID) {
-        var internal;
-        (internal = ReactInstanceMap_1.get(inst)) && (inst = internal);
-    }
-    return inst._debugID;
-};
-
-setChildrenForInstrumentation = function(children) {
-    var debugID = getDebugID(this);
-    0 !== debugID && ReactInstrumentation.debugTool.onSetChildren(debugID, children ? Object.keys(children).map(function(key) {
-        return children[key]._debugID;
-    }) : []);
-};
-
-var ReactMultiChild = {
-    _reconcilerInstantiateChildren: function(nestedChildren, transaction, context) {
-        var selfDebugID = getDebugID(this);
-        if (this._currentElement) try {
-            return ReactCurrentOwner$3.current = this._currentElement._owner, ReactChildReconciler_1.instantiateChildren(nestedChildren, transaction, context, selfDebugID);
-        } finally {
-            ReactCurrentOwner$3.current = null;
+    var ReactComponentTreeHook$4, ReactChildReconciler = {
+        instantiateChildren: function(nestedChildNodes, transaction, context, selfDebugID) {
+            if (null == nestedChildNodes) return null;
+            var childInstances = {};
+            return traverseStackChildren_1(nestedChildNodes, function(childInsts, child, name) {
+                return instantiateChild(childInsts, child, name, selfDebugID);
+            }, childInstances), childInstances;
+        },
+        updateChildren: function(prevChildren, nextChildren, mountImages, removedNodes, transaction, hostParent, hostContainerInfo, context, selfDebugID) {
+            if (nextChildren || prevChildren) {
+                var name, prevChild;
+                for (name in nextChildren) if (nextChildren.hasOwnProperty(name)) {
+                    prevChild = prevChildren && prevChildren[name];
+                    var prevElement = prevChild && prevChild._currentElement, nextElement = nextChildren[name];
+                    if (null != prevChild && shouldUpdateReactComponent_1(prevElement, nextElement)) ReactReconciler_1.receiveComponent(prevChild, nextElement, transaction, context), 
+                    nextChildren[name] = prevChild; else {
+                        var nextChildInstance = instantiateReactComponent_1(nextElement, !0);
+                        nextChildren[name] = nextChildInstance;
+                        var nextChildMountImage = ReactReconciler_1.mountComponent(nextChildInstance, transaction, hostParent, hostContainerInfo, context, selfDebugID);
+                        mountImages.push(nextChildMountImage), prevChild && (removedNodes[name] = ReactReconciler_1.getHostNode(prevChild), 
+                        ReactReconciler_1.unmountComponent(prevChild, !1, !1));
+                    }
+                }
+                for (name in prevChildren) !prevChildren.hasOwnProperty(name) || nextChildren && nextChildren.hasOwnProperty(name) || (prevChild = prevChildren[name], 
+                removedNodes[name] = ReactReconciler_1.getHostNode(prevChild), ReactReconciler_1.unmountComponent(prevChild, !1, !1));
+            }
+        },
+        unmountChildren: function(renderedChildren, safely, skipLifecycle) {
+            for (var name in renderedChildren) if (renderedChildren.hasOwnProperty(name)) {
+                var renderedChild = renderedChildren[name];
+                ReactReconciler_1.unmountComponent(renderedChild, safely, skipLifecycle);
+            }
         }
-        return ReactChildReconciler_1.instantiateChildren(nestedChildren, transaction, context);
-    },
-    _reconcilerUpdateChildren: function(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context) {
-        var nextChildren, selfDebugID = 0;
-        if (selfDebugID = getDebugID(this), this._currentElement) {
-            try {
-                ReactCurrentOwner$3.current = this._currentElement._owner, nextChildren = flattenStackChildren_1(nextNestedChildrenElements, selfDebugID);
+    }, ReactChildReconciler_1 = ReactChildReconciler;
+    "undefined" != typeof process && process.env && "development" == "test" && (ReactComponentTreeHook$4 = ReactGlobalSharedState_1.ReactComponentTreeHook);
+    function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
+        if (traverseContext && "object" == typeof traverseContext) {
+            var result = traverseContext, keyUnique = void 0 === result[name];
+            ReactComponentTreeHook$4 || (ReactComponentTreeHook$4 = ReactGlobalSharedState_1.ReactComponentTreeHook), 
+            keyUnique || warning(!1, "flattenChildren(...): 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", KeyEscapeUtils_1.unescapeInDev(name), ReactComponentTreeHook$4.getStackAddendumByID(selfDebugID)), 
+            keyUnique && null != child && (result[name] = child);
+        }
+    }
+    function flattenStackChildren(children, selfDebugID) {
+        if (null == children) return children;
+        var result = {};
+        return traverseStackChildren_1(children, function(traverseContext, child, name) {
+            return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
+        }, result), result;
+    }
+    var flattenStackChildren_1 = flattenStackChildren, ReactCurrentOwner$3 = ReactGlobalSharedState_1.ReactCurrentOwner, _require2$1 = ReactGlobalSharedState_1, ReactDebugCurrentFrame$1 = _require2$1.ReactDebugCurrentFrame, ReactDebugCurrentStack$2 = ReactDebugCurrentStack_1;
+    function makeInsertMarkup(markup, afterNode, toIndex) {
+        return {
+            type: "INSERT_MARKUP",
+            content: markup,
+            fromIndex: null,
+            fromNode: null,
+            toIndex: toIndex,
+            afterNode: afterNode
+        };
+    }
+    function makeMove(child, afterNode, toIndex) {
+        return {
+            type: "MOVE_EXISTING",
+            content: null,
+            fromIndex: child._mountIndex,
+            fromNode: ReactReconciler_1.getHostNode(child),
+            toIndex: toIndex,
+            afterNode: afterNode
+        };
+    }
+    function makeRemove(child, node) {
+        return {
+            type: "REMOVE_NODE",
+            content: null,
+            fromIndex: child._mountIndex,
+            fromNode: node,
+            toIndex: null,
+            afterNode: null
+        };
+    }
+    function makeSetMarkup(markup) {
+        return {
+            type: "SET_MARKUP",
+            content: markup,
+            fromIndex: null,
+            fromNode: null,
+            toIndex: null,
+            afterNode: null
+        };
+    }
+    function makeTextContent(textContent) {
+        return {
+            type: "TEXT_CONTENT",
+            content: textContent,
+            fromIndex: null,
+            fromNode: null,
+            toIndex: null,
+            afterNode: null
+        };
+    }
+    function enqueue(queue, update) {
+        return update && (queue = queue || [], queue.push(update)), queue;
+    }
+    function processQueue(inst, updateQueue) {
+        ReactComponentEnvironment_1.processChildrenUpdates(inst, updateQueue);
+    }
+    var setChildrenForInstrumentation = emptyFunction, getDebugID = function(inst) {
+        if (!inst._debugID) {
+            var internal;
+            (internal = ReactInstanceMap_1.get(inst)) && (inst = internal);
+        }
+        return inst._debugID;
+    };
+    setChildrenForInstrumentation = function(children) {
+        var debugID = getDebugID(this);
+        0 !== debugID && ReactInstrumentation.debugTool.onSetChildren(debugID, children ? Object.keys(children).map(function(key) {
+            return children[key]._debugID;
+        }) : []);
+    };
+    var ReactMultiChild = {
+        _reconcilerInstantiateChildren: function(nestedChildren, transaction, context) {
+            var selfDebugID = getDebugID(this);
+            if (this._currentElement) try {
+                return ReactCurrentOwner$3.current = this._currentElement._owner, ReactDebugCurrentFrame$1.getCurrentStack = ReactDebugCurrentStack$2.getStackAddendum, 
+                ReactChildReconciler_1.instantiateChildren(nestedChildren, transaction, context, selfDebugID);
             } finally {
-                ReactCurrentOwner$3.current = null;
+                ReactCurrentOwner$3.current = null, ReactDebugCurrentFrame$1.getCurrentStack = null;
             }
-            return ReactChildReconciler_1.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID), 
+            return ReactChildReconciler_1.instantiateChildren(nestedChildren, transaction, context);
+        },
+        _reconcilerUpdateChildren: function(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context) {
+            var nextChildren, selfDebugID = 0;
+            if (selfDebugID = getDebugID(this), this._currentElement) {
+                try {
+                    ReactCurrentOwner$3.current = this._currentElement._owner, ReactDebugCurrentFrame$1.getCurrentStack = ReactDebugCurrentStack$2.getStackAddendum, 
+                    nextChildren = flattenStackChildren_1(nextNestedChildrenElements, selfDebugID);
+                } finally {
+                    ReactCurrentOwner$3.current = null, ReactDebugCurrentFrame$1.getCurrentStack = null;
+                }
+                return ReactChildReconciler_1.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID), 
+                nextChildren;
+            }
+            return nextChildren = flattenStackChildren_1(nextNestedChildrenElements, selfDebugID), 
+            ReactChildReconciler_1.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID), 
             nextChildren;
-        }
-        return nextChildren = flattenStackChildren_1(nextNestedChildrenElements, selfDebugID), 
-        ReactChildReconciler_1.updateChildren(prevChildren, nextChildren, mountImages, removedNodes, transaction, this, this._hostContainerInfo, context, selfDebugID), 
-        nextChildren;
-    },
-    mountChildren: function(nestedChildren, transaction, context) {
-        var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);
-        this._renderedChildren = children;
-        var mountImages = [], index = 0;
-        for (var name in children) if (children.hasOwnProperty(name)) {
-            var child = children[name], selfDebugID = 0;
-            selfDebugID = getDebugID(this);
-            var mountImage = ReactReconciler_1.mountComponent(child, transaction, this, this._hostContainerInfo, context, selfDebugID);
-            child._mountIndex = index++, mountImages.push(mountImage);
-        }
-        return setChildrenForInstrumentation.call(this, children), mountImages;
-    },
-    updateTextContent: function(nextContent) {
-        var prevChildren = this._renderedChildren;
-        ReactChildReconciler_1.unmountChildren(prevChildren, !1, !1);
-        for (var name in prevChildren) prevChildren.hasOwnProperty(name) && invariant(!1, "updateTextContent called on non-empty component.");
-        processQueue(this, [ makeTextContent(nextContent) ]);
-    },
-    updateMarkup: function(nextMarkup) {
-        var prevChildren = this._renderedChildren;
-        ReactChildReconciler_1.unmountChildren(prevChildren, !1, !1);
-        for (var name in prevChildren) prevChildren.hasOwnProperty(name) && invariant(!1, "updateTextContent called on non-empty component.");
-        processQueue(this, [ makeSetMarkup(nextMarkup) ]);
-    },
-    updateChildren: function(nextNestedChildrenElements, transaction, context) {
-        this._updateChildren(nextNestedChildrenElements, transaction, context);
-    },
-    _updateChildren: function(nextNestedChildrenElements, transaction, context) {
-        var prevChildren = this._renderedChildren, removedNodes = {}, mountImages = [], nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context);
-        if (nextChildren || prevChildren) {
-            var name, updates = null, nextIndex = 0, lastIndex = 0, nextMountIndex = 0, lastPlacedNode = null;
-            for (name in nextChildren) if (nextChildren.hasOwnProperty(name)) {
-                var prevChild = prevChildren && prevChildren[name], nextChild = nextChildren[name];
-                prevChild === nextChild ? (updates = enqueue(updates, this.moveChild(prevChild, lastPlacedNode, nextIndex, lastIndex)), 
-                lastIndex = Math.max(prevChild._mountIndex, lastIndex), prevChild._mountIndex = nextIndex) : (prevChild && (lastIndex = Math.max(prevChild._mountIndex, lastIndex)), 
-                updates = enqueue(updates, this._mountChildAtIndex(nextChild, mountImages[nextMountIndex], lastPlacedNode, nextIndex, transaction, context)), 
-                nextMountIndex++), nextIndex++, lastPlacedNode = ReactReconciler_1.getHostNode(nextChild);
+        },
+        mountChildren: function(nestedChildren, transaction, context) {
+            var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context);
+            this._renderedChildren = children;
+            var mountImages = [], index = 0;
+            for (var name in children) if (children.hasOwnProperty(name)) {
+                var child = children[name], selfDebugID = 0;
+                selfDebugID = getDebugID(this);
+                var mountImage = ReactReconciler_1.mountComponent(child, transaction, this, this._hostContainerInfo, context, selfDebugID);
+                child._mountIndex = index++, mountImages.push(mountImage);
             }
-            for (name in removedNodes) removedNodes.hasOwnProperty(name) && (updates = enqueue(updates, this._unmountChild(prevChildren[name], removedNodes[name])));
-            updates && processQueue(this, updates), this._renderedChildren = nextChildren, setChildrenForInstrumentation.call(this, nextChildren);
-        }
-    },
-    unmountChildren: function(safely, skipLifecycle) {
-        var renderedChildren = this._renderedChildren;
-        ReactChildReconciler_1.unmountChildren(renderedChildren, safely, skipLifecycle), 
-        this._renderedChildren = null;
-    },
-    moveChild: function(child, afterNode, toIndex, lastIndex) {
-        if (child._mountIndex < lastIndex) return makeMove(child, afterNode, toIndex);
-    },
-    createChild: function(child, afterNode, mountImage) {
-        return makeInsertMarkup(mountImage, afterNode, child._mountIndex);
-    },
-    removeChild: function(child, node) {
-        return makeRemove(child, node);
-    },
-    _mountChildAtIndex: function(child, mountImage, afterNode, index, transaction, context) {
-        return child._mountIndex = index, this.createChild(child, afterNode, mountImage);
-    },
-    _unmountChild: function(child, node) {
-        var update = this.removeChild(child, node);
-        return child._mountIndex = null, update;
-    }
-}, ReactMultiChild_1 = ReactMultiChild, ReactNativeBaseComponent = function(viewConfig) {
-    this.viewConfig = viewConfig;
-};
-
-ReactNativeBaseComponent.Mixin = {
-    getPublicInstance: function() {
-        return this;
-    },
-    unmountComponent: function(safely, skipLifecycle) {
-        ReactNativeComponentTree_1.uncacheNode(this), this.unmountChildren(safely, skipLifecycle), 
-        this._rootNodeID = 0;
-    },
-    initializeChildren: function(children, containerTag, transaction, context) {
-        var mountImages = this.mountChildren(children, transaction, context);
-        if (mountImages.length) {
-            for (var createdTags = [], i = 0, l = mountImages.length; i < l; i++) {
-                var mountImage = mountImages[i], childTag = mountImage;
-                createdTags[i] = childTag;
+            return setChildrenForInstrumentation.call(this, children), mountImages;
+        },
+        updateTextContent: function(nextContent) {
+            var prevChildren = this._renderedChildren;
+            ReactChildReconciler_1.unmountChildren(prevChildren, !1, !1);
+            for (var name in prevChildren) prevChildren.hasOwnProperty(name) && invariant(!1, "updateTextContent called on non-empty component.");
+            processQueue(this, [ makeTextContent(nextContent) ]);
+        },
+        updateMarkup: function(nextMarkup) {
+            var prevChildren = this._renderedChildren;
+            ReactChildReconciler_1.unmountChildren(prevChildren, !1, !1);
+            for (var name in prevChildren) prevChildren.hasOwnProperty(name) && invariant(!1, "updateTextContent called on non-empty component.");
+            processQueue(this, [ makeSetMarkup(nextMarkup) ]);
+        },
+        updateChildren: function(nextNestedChildrenElements, transaction, context) {
+            this._updateChildren(nextNestedChildrenElements, transaction, context);
+        },
+        _updateChildren: function(nextNestedChildrenElements, transaction, context) {
+            var prevChildren = this._renderedChildren, removedNodes = {}, mountImages = [], nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, mountImages, removedNodes, transaction, context);
+            if (nextChildren || prevChildren) {
+                var name, updates = null, nextIndex = 0, lastIndex = 0, nextMountIndex = 0, lastPlacedNode = null;
+                for (name in nextChildren) if (nextChildren.hasOwnProperty(name)) {
+                    var prevChild = prevChildren && prevChildren[name], nextChild = nextChildren[name];
+                    prevChild === nextChild ? (updates = enqueue(updates, this.moveChild(prevChild, lastPlacedNode, nextIndex, lastIndex)), 
+                    lastIndex = Math.max(prevChild._mountIndex, lastIndex), prevChild._mountIndex = nextIndex) : (prevChild && (lastIndex = Math.max(prevChild._mountIndex, lastIndex)), 
+                    updates = enqueue(updates, this._mountChildAtIndex(nextChild, mountImages[nextMountIndex], lastPlacedNode, nextIndex, transaction, context)), 
+                    nextMountIndex++), nextIndex++, lastPlacedNode = ReactReconciler_1.getHostNode(nextChild);
+                }
+                for (name in removedNodes) removedNodes.hasOwnProperty(name) && (updates = enqueue(updates, this._unmountChild(prevChildren[name], removedNodes[name])));
+                updates && processQueue(this, updates), this._renderedChildren = nextChildren, setChildrenForInstrumentation.call(this, nextChildren);
             }
-            UIManager.setChildren(containerTag, createdTags);
+        },
+        unmountChildren: function(safely, skipLifecycle) {
+            var renderedChildren = this._renderedChildren;
+            ReactChildReconciler_1.unmountChildren(renderedChildren, safely, skipLifecycle), 
+            this._renderedChildren = null;
+        },
+        moveChild: function(child, afterNode, toIndex, lastIndex) {
+            if (child._mountIndex < lastIndex) return makeMove(child, afterNode, toIndex);
+        },
+        createChild: function(child, afterNode, mountImage) {
+            return makeInsertMarkup(mountImage, afterNode, child._mountIndex);
+        },
+        removeChild: function(child, node) {
+            return makeRemove(child, node);
+        },
+        _mountChildAtIndex: function(child, mountImage, afterNode, index, transaction, context) {
+            return child._mountIndex = index, this.createChild(child, afterNode, mountImage);
+        },
+        _unmountChild: function(child, node) {
+            var update = this.removeChild(child, node);
+            return child._mountIndex = null, update;
         }
-    },
-    receiveComponent: function(nextElement, transaction, context) {
-        var prevElement = this._currentElement;
-        this._currentElement = nextElement;
-        for (var key in this.viewConfig.validAttributes) nextElement.props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(nextElement.props[key]);
-        var updatePayload = ReactNativeAttributePayload_1.diff(prevElement.props, nextElement.props, this.viewConfig.validAttributes);
-        updatePayload && UIManager.updateView(this._rootNodeID, this.viewConfig.uiViewClassName, updatePayload), 
-        this.updateChildren(nextElement.props.children, transaction, context);
-    },
-    getName: function() {
-        return this.constructor.displayName || this.constructor.name || "Unknown";
-    },
-    getHostNode: function() {
-        return this._rootNodeID;
-    },
-    mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
-        var tag = ReactNativeTagHandles_1.allocateTag();
-        this._rootNodeID = tag, this._hostParent = hostParent, this._hostContainerInfo = hostContainerInfo;
-        for (var key in this.viewConfig.validAttributes) this._currentElement.props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(this._currentElement.props[key]);
-        var updatePayload = ReactNativeAttributePayload_1.create(this._currentElement.props, this.viewConfig.validAttributes), nativeTopRootTag = hostContainerInfo._tag;
-        return UIManager.createView(tag, this.viewConfig.uiViewClassName, nativeTopRootTag, updatePayload), 
-        ReactNativeComponentTree_1.precacheNode(this, tag), this.initializeChildren(this._currentElement.props.children, tag, transaction, context), 
-        tag;
-    }
-}, Object.assign(ReactNativeBaseComponent.prototype, ReactMultiChild_1, ReactNativeBaseComponent.Mixin, NativeMethodsMixin_1);
-
-var ReactNativeBaseComponent_1 = ReactNativeBaseComponent, createReactNativeComponentClassStack = function(viewConfig) {
-    var Constructor = function(element) {
-        this._currentElement = element, this._topLevelWrapper = null, this._hostParent = null, 
-        this._hostContainerInfo = null, this._rootNodeID = 0, this._renderedChildren = null;
+    }, ReactMultiChild_1 = ReactMultiChild, ReactNativeBaseComponent = function(viewConfig) {
+        this.viewConfig = viewConfig;
     };
-    return Constructor.displayName = viewConfig.uiViewClassName, Constructor.viewConfig = viewConfig, 
-    Constructor.propTypes = viewConfig.propTypes, Constructor.prototype = new ReactNativeBaseComponent_1(viewConfig), 
-    Constructor.prototype.constructor = Constructor, Constructor;
-}, createReactNativeComponentClassStack_1 = createReactNativeComponentClassStack, ReactNativeFeatureFlags$3 = require("ReactNativeFeatureFlags"), createReactNativeComponentClass = ReactNativeFeatureFlags$3.useFiber ? DevOnlyStubShim : createReactNativeComponentClassStack_1, ReactNativeFeatureFlags$4 = require("ReactNativeFeatureFlags"), findNumericNodeHandle$2 = ReactNativeFeatureFlags$4.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack;
-
-function takeSnapshot(view, options) {
-    return "number" != typeof view && "window" !== view && (view = findNumericNodeHandle$2(view) || "window"), 
-    UIManager.__takeSnapshot(view, options);
-}
-
-var takeSnapshot_1 = takeSnapshot, lowPriorityWarning = function() {}, printWarning = function(format) {
-    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
-    var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
-        return args[argIndex++];
-    });
-    "undefined" != typeof console && console.warn(message);
-    try {
-        throw new Error(message);
-    } catch (x) {}
-};
-
-lowPriorityWarning = function(condition, format) {
-    if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning " + "message argument");
-    if (!condition) {
-        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2];
-        printWarning.apply(void 0, [ format ].concat(args));
-    }
-};
-
-var lowPriorityWarning_1 = lowPriorityWarning, _extends$2 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-};
-
-function roundFloat(val) {
-    var base = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 2, n = Math.pow(10, base);
-    return Math.floor(val * n) / n;
-}
-
-function consoleTable(table) {
-    console.table(table);
-}
-
-function getLastMeasurements() {
-    return ReactDebugTool_1.getFlushHistory();
-}
-
-function getExclusive() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, timerType, applyUpdate) {
-        var displayName = treeSnapshot[instanceID].displayName, key = displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            counts: {},
-            durations: {},
-            totalDuration: 0
-        }), stats.durations[timerType] || (stats.durations[timerType] = 0), stats.counts[timerType] || (stats.counts[timerType] = 0), 
-        affectedIDs[key][instanceID] = !0, applyUpdate(stats);
-    }
-    return flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
-        measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID, timerType = measurement.timerType;
-            updateAggregatedStats(treeSnapshot, instanceID, timerType, function(stats) {
-                stats.totalDuration += duration, stats.durations[timerType] += duration, stats.counts[timerType]++;
-            });
-        });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$2({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.totalDuration - a.totalDuration;
-    });
-}
-
-function getInclusive() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
-        var _treeSnapshot$instanc = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc.displayName, ownerID = _treeSnapshot$instanc.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            inclusiveRenderDuration: 0,
-            renderCount: 0
-        }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
-    }
-    var isCompositeByID = {};
-    return flushHistory.forEach(function(flush) {
-        flush.measurements.forEach(function(measurement) {
-            var instanceID = measurement.instanceID;
-            "render" === measurement.timerType && (isCompositeByID[instanceID] = !0);
-        });
-    }), flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
-        measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID;
-            if ("render" === measurement.timerType) {
-                updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
-                    stats.renderCount++;
-                });
-                for (var nextParentID = instanceID; nextParentID; ) isCompositeByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
-                    stats.inclusiveRenderDuration += duration;
-                }), nextParentID = treeSnapshot[nextParentID].parentID;
+    ReactNativeBaseComponent.Mixin = {
+        getPublicInstance: function() {
+            return this;
+        },
+        unmountComponent: function(safely, skipLifecycle) {
+            ReactNativeComponentTree_1.uncacheNode(this), this.unmountChildren(safely, skipLifecycle), 
+            this._rootNodeID = 0;
+        },
+        initializeChildren: function(children, containerTag, transaction, context) {
+            var mountImages = this.mountChildren(children, transaction, context);
+            if (mountImages.length) {
+                for (var createdTags = [], i = 0, l = mountImages.length; i < l; i++) {
+                    var mountImage = mountImages[i], childTag = mountImage;
+                    createdTags[i] = childTag;
+                }
+                UIManager.setChildren(containerTag, createdTags);
             }
-        });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$2({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
-    });
-}
-
-function getWasted() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
-    function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
-        var _treeSnapshot$instanc2 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc2.displayName, ownerID = _treeSnapshot$instanc2.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
-        stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
-            key: key,
-            instanceCount: 0,
-            inclusiveRenderDuration: 0,
-            renderCount: 0
-        }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        },
+        receiveComponent: function(nextElement, transaction, context) {
+            var prevElement = this._currentElement;
+            this._currentElement = nextElement;
+            for (var key in this.viewConfig.validAttributes) nextElement.props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(nextElement.props[key]);
+            var updatePayload = ReactNativeAttributePayload_1.diff(prevElement.props, nextElement.props, this.viewConfig.validAttributes);
+            updatePayload && UIManager.updateView(this._rootNodeID, this.viewConfig.uiViewClassName, updatePayload), 
+            this.updateChildren(nextElement.props.children, transaction, context);
+        },
+        getName: function() {
+            return this.constructor.displayName || this.constructor.name || "Unknown";
+        },
+        getHostNode: function() {
+            return this._rootNodeID;
+        },
+        mountComponent: function(transaction, hostParent, hostContainerInfo, context) {
+            var tag = ReactNativeTagHandles_1.allocateTag();
+            this._rootNodeID = tag, this._hostParent = hostParent, this._hostContainerInfo = hostContainerInfo;
+            for (var key in this.viewConfig.validAttributes) this._currentElement.props.hasOwnProperty(key) && deepFreezeAndThrowOnMutationInDev(this._currentElement.props[key]);
+            var updatePayload = ReactNativeAttributePayload_1.create(this._currentElement.props, this.viewConfig.validAttributes), nativeTopRootTag = hostContainerInfo._tag;
+            return UIManager.createView(tag, this.viewConfig.uiViewClassName, nativeTopRootTag, updatePayload), 
+            ReactNativeComponentTree_1.precacheNode(this, tag), this.initializeChildren(this._currentElement.props.children, tag, transaction, context), 
+            tag;
+        }
+    }, Object.assign(ReactNativeBaseComponent.prototype, ReactMultiChild_1, ReactNativeBaseComponent.Mixin, NativeMethodsMixin_1);
+    var ReactNativeBaseComponent_1 = ReactNativeBaseComponent, createReactNativeComponentClassStack = function(viewConfig) {
+        var Constructor = function(element) {
+            this._currentElement = element, this._topLevelWrapper = null, this._hostParent = null, 
+            this._hostContainerInfo = null, this._rootNodeID = 0, this._renderedChildren = null;
+        };
+        return Constructor.displayName = viewConfig.uiViewClassName, Constructor.viewConfig = viewConfig, 
+        Constructor.propTypes = viewConfig.propTypes, Constructor.prototype = new ReactNativeBaseComponent_1(viewConfig), 
+        Constructor.prototype.constructor = Constructor, Constructor;
+    }, createReactNativeComponentClassStack_1 = createReactNativeComponentClassStack, ReactNativeFeatureFlags$3 = require("ReactNativeFeatureFlags"), createReactNativeComponentClass = ReactNativeFeatureFlags$3.useFiber ? DevOnlyStubShim : createReactNativeComponentClassStack_1, ReactNativeFeatureFlags$4 = require("ReactNativeFeatureFlags"), findNumericNodeHandle$2 = ReactNativeFeatureFlags$4.useFiber ? DevOnlyStubShim : findNumericNodeHandleStack;
+    function takeSnapshot(view, options) {
+        return "number" != typeof view && "window" !== view && (view = findNumericNodeHandle$2(view) || "window"), 
+        UIManager.__takeSnapshot(view, options);
     }
-    return flushHistory.forEach(function(flush) {
-        var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot, operations = flush.operations, isDefinitelyNotWastedByID = {};
-        operations.forEach(function(operation) {
-            for (var instanceID = operation.instanceID, nextParentID = instanceID; nextParentID; ) isDefinitelyNotWastedByID[nextParentID] = !0, 
-            nextParentID = treeSnapshot[nextParentID].parentID;
+    var takeSnapshot_1 = takeSnapshot, lowPriorityWarning = function() {}, printWarning = function(format) {
+        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) args[_key - 1] = arguments[_key];
+        var argIndex = 0, message = "Warning: " + format.replace(/%s/g, function() {
+            return args[argIndex++];
         });
-        var renderedCompositeIDs = {};
-        measurements.forEach(function(measurement) {
-            var instanceID = measurement.instanceID;
-            "render" === measurement.timerType && (renderedCompositeIDs[instanceID] = !0);
-        }), measurements.forEach(function(measurement) {
-            var duration = measurement.duration, instanceID = measurement.instanceID;
-            if ("render" === measurement.timerType) {
-                var updateCount = treeSnapshot[instanceID].updateCount;
-                if (!isDefinitelyNotWastedByID[instanceID] && 0 !== updateCount) {
+        "undefined" != typeof console && console.warn(message);
+        try {
+            throw new Error(message);
+        } catch (x) {}
+    };
+    lowPriorityWarning = function(condition, format) {
+        if (void 0 === format) throw new Error("`warning(condition, format, ...args)` requires a warning " + "message argument");
+        if (!condition) {
+            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) args[_key2 - 2] = arguments[_key2];
+            printWarning.apply(void 0, [ format ].concat(args));
+        }
+    };
+    var lowPriorityWarning_1 = lowPriorityWarning;
+    function roundFloat(val) {
+        var base = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 2, n = Math.pow(10, base);
+        return Math.floor(val * n) / n;
+    }
+    function consoleTable(table) {
+        console.table(table);
+    }
+    function getLastMeasurements() {
+        return ReactDebugTool_1.getFlushHistory();
+    }
+    function getExclusive() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, timerType, applyUpdate) {
+            var displayName = treeSnapshot[instanceID].displayName, key = displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                counts: {},
+                durations: {},
+                totalDuration: 0
+            }), stats.durations[timerType] || (stats.durations[timerType] = 0), stats.counts[timerType] || (stats.counts[timerType] = 0), 
+            affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        }
+        return flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
+            measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID, timerType = measurement.timerType;
+                updateAggregatedStats(treeSnapshot, instanceID, timerType, function(stats) {
+                    stats.totalDuration += duration, stats.durations[timerType] += duration, stats.counts[timerType]++;
+                });
+            });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.totalDuration - a.totalDuration;
+        });
+    }
+    function getInclusive() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
+            var _treeSnapshot$instanc = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc.displayName, ownerID = _treeSnapshot$instanc.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                inclusiveRenderDuration: 0,
+                renderCount: 0
+            }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
+        }
+        var isCompositeByID = {};
+        return flushHistory.forEach(function(flush) {
+            flush.measurements.forEach(function(measurement) {
+                var instanceID = measurement.instanceID;
+                "render" === measurement.timerType && (isCompositeByID[instanceID] = !0);
+            });
+        }), flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot;
+            measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID;
+                if ("render" === measurement.timerType) {
                     updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
                         stats.renderCount++;
                     });
-                    for (var nextParentID = instanceID; nextParentID; ) renderedCompositeIDs[nextParentID] && !isDefinitelyNotWastedByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
+                    for (var nextParentID = instanceID; nextParentID; ) isCompositeByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
                         stats.inclusiveRenderDuration += duration;
                     }), nextParentID = treeSnapshot[nextParentID].parentID;
                 }
-            }
-        });
-    }), Object.keys(aggregatedStats).map(function(key) {
-        return _extends$2({}, aggregatedStats[key], {
-            instanceCount: Object.keys(affectedIDs[key]).length
-        });
-    }).sort(function(a, b) {
-        return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
-    });
-}
-
-function getOperations() {
-    var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), stats = [];
-    return flushHistory.forEach(function(flush, flushIndex) {
-        var operations = flush.operations, treeSnapshot = flush.treeSnapshot;
-        operations.forEach(function(operation) {
-            var instanceID = operation.instanceID, type = operation.type, payload = operation.payload, _treeSnapshot$instanc3 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc3.displayName, ownerID = _treeSnapshot$instanc3.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName;
-            stats.push({
-                flushIndex: flushIndex,
-                instanceID: instanceID,
-                key: key,
-                type: type,
-                ownerID: ownerID,
-                payload: payload
             });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
         });
-    }), stats;
-}
-
-function printExclusive(flushHistory) {
-    consoleTable(getExclusive(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, totalDuration = item.totalDuration, renderCount = item.counts.render || 0, renderDuration = item.durations.render || 0;
-        return {
-            Component: key,
-            "Total time (ms)": roundFloat(totalDuration),
-            "Instance count": instanceCount,
-            "Total render time (ms)": roundFloat(renderDuration),
-            "Average render time (ms)": renderCount ? roundFloat(renderDuration / renderCount) : void 0,
-            "Render count": renderCount,
-            "Total lifecycle time (ms)": roundFloat(totalDuration - renderDuration)
-        };
-    }));
-}
-
-function printInclusive(flushHistory) {
-    consoleTable(getInclusive(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
-        return {
-            "Owner > Component": key,
-            "Inclusive render time (ms)": roundFloat(inclusiveRenderDuration),
-            "Instance count": instanceCount,
-            "Render count": renderCount
-        };
-    }));
-}
-
-function printWasted(flushHistory) {
-    consoleTable(getWasted(flushHistory).map(function(item) {
-        var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
-        return {
-            "Owner > Component": key,
-            "Inclusive wasted time (ms)": roundFloat(inclusiveRenderDuration),
-            "Instance count": instanceCount,
-            "Render count": renderCount
-        };
-    }));
-}
-
-function printOperations(flushHistory) {
-    consoleTable(getOperations(flushHistory).map(function(stat) {
-        return {
-            "Owner > Node": stat.key,
-            Operation: stat.type,
-            Payload: "object" == typeof stat.payload ? JSON.stringify(stat.payload) : stat.payload,
-            "Flush index": stat.flushIndex,
-            "Owner Component ID": stat.ownerID,
-            "DOM Component ID": stat.instanceID
-        };
-    }));
-}
-
-var warnedAboutPrintDOM = !1;
-
-function printDOM(measurements) {
-    return lowPriorityWarning_1(warnedAboutPrintDOM, "`ReactPerf.printDOM(...)` is deprecated. Use " + "`ReactPerf.printOperations(...)` instead."), 
-    warnedAboutPrintDOM = !0, printOperations(measurements);
-}
-
-var warnedAboutGetMeasurementsSummaryMap = !1;
-
-function getMeasurementsSummaryMap(measurements) {
-    return lowPriorityWarning_1(warnedAboutGetMeasurementsSummaryMap, "`ReactPerf.getMeasurementsSummaryMap(...)` is deprecated. Use " + "`ReactPerf.getWasted(...)` instead."), 
-    warnedAboutGetMeasurementsSummaryMap = !0, getWasted(measurements);
-}
-
-function start() {
-    ReactDebugTool_1.beginProfiling();
-}
-
-function stop() {
-    ReactDebugTool_1.endProfiling();
-}
-
-function isRunning() {
-    return ReactDebugTool_1.isProfiling();
-}
-
-var ReactPerfAnalysis = {
-    getLastMeasurements: getLastMeasurements,
-    getExclusive: getExclusive,
-    getInclusive: getInclusive,
-    getWasted: getWasted,
-    getOperations: getOperations,
-    printExclusive: printExclusive,
-    printInclusive: printInclusive,
-    printWasted: printWasted,
-    printOperations: printOperations,
-    start: start,
-    stop: stop,
-    isRunning: isRunning,
-    printDOM: printDOM,
-    getMeasurementsSummaryMap: getMeasurementsSummaryMap
-}, ReactPerf = ReactPerfAnalysis;
-
-ReactNativeInjection.inject(), ReactNativeStackInjection.inject();
-
-var render = function(element, mountInto, callback) {
-    return ReactNativeMount_1.renderComponent(element, mountInto, callback);
-}, ReactNativeStack = {
-    NativeComponent: ReactNativeComponent_1,
-    hasReactNativeInitialized: !1,
-    findNodeHandle: findNumericNodeHandleStack,
-    render: render,
-    unmountComponentAtNode: ReactNativeMount_1.unmountComponentAtNode,
-    unstable_batchedUpdates: ReactUpdates_1.batchedUpdates,
-    unmountComponentAtNodeAndRemoveContainer: ReactNativeMount_1.unmountComponentAtNodeAndRemoveContainer,
-    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
-        NativeMethodsMixin: NativeMethodsMixin_1,
-        ReactGlobalSharedState: ReactGlobalSharedState_1,
-        ReactNativeComponentTree: ReactNativeComponentTree_1,
-        ReactNativePropRegistry: ReactNativePropRegistry_1,
-        TouchHistoryMath: TouchHistoryMath_1,
-        createReactNativeComponentClass: createReactNativeComponentClass,
-        takeSnapshot: takeSnapshot_1
     }
-};
-
-Object.assign(ReactNativeStack.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
-    ReactDebugTool: ReactDebugTool_1,
-    ReactPerf: ReactPerf
-}), "undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject && __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
-    ComponentTree: {
-        getClosestInstanceFromNode: function(node) {
-            return ReactNativeComponentTree_1.getClosestInstanceFromNode(node);
-        },
-        getNodeFromInstance: function(inst) {
-            for (;inst._renderedComponent; ) inst = inst._renderedComponent;
-            return inst ? ReactNativeComponentTree_1.getNodeFromInstance(inst) : null;
+    function getWasted() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), aggregatedStats = {}, affectedIDs = {};
+        function updateAggregatedStats(treeSnapshot, instanceID, applyUpdate) {
+            var _treeSnapshot$instanc2 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc2.displayName, ownerID = _treeSnapshot$instanc2.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName, stats = aggregatedStats[key];
+            stats || (affectedIDs[key] = {}, stats = aggregatedStats[key] = {
+                key: key,
+                instanceCount: 0,
+                inclusiveRenderDuration: 0,
+                renderCount: 0
+            }), affectedIDs[key][instanceID] = !0, applyUpdate(stats);
         }
-    },
-    Mount: ReactNativeMount_1,
-    Reconciler: ReactReconciler_1,
-    getInspectorDataForViewTag: ReactNativeStackInspector.getInspectorDataForViewTag
-});
-
-var ReactNativeStackEntry = ReactNativeStack;
-
-module.exports = ReactNativeStackEntry;
+        return flushHistory.forEach(function(flush) {
+            var measurements = flush.measurements, treeSnapshot = flush.treeSnapshot, operations = flush.operations, isDefinitelyNotWastedByID = {};
+            operations.forEach(function(operation) {
+                for (var instanceID = operation.instanceID, nextParentID = instanceID; nextParentID; ) isDefinitelyNotWastedByID[nextParentID] = !0, 
+                nextParentID = treeSnapshot[nextParentID].parentID;
+            });
+            var renderedCompositeIDs = {};
+            measurements.forEach(function(measurement) {
+                var instanceID = measurement.instanceID;
+                "render" === measurement.timerType && (renderedCompositeIDs[instanceID] = !0);
+            }), measurements.forEach(function(measurement) {
+                var duration = measurement.duration, instanceID = measurement.instanceID;
+                if ("render" === measurement.timerType) {
+                    var updateCount = treeSnapshot[instanceID].updateCount;
+                    if (!isDefinitelyNotWastedByID[instanceID] && 0 !== updateCount) {
+                        updateAggregatedStats(treeSnapshot, instanceID, function(stats) {
+                            stats.renderCount++;
+                        });
+                        for (var nextParentID = instanceID; nextParentID; ) renderedCompositeIDs[nextParentID] && !isDefinitelyNotWastedByID[nextParentID] && updateAggregatedStats(treeSnapshot, nextParentID, function(stats) {
+                            stats.inclusiveRenderDuration += duration;
+                        }), nextParentID = treeSnapshot[nextParentID].parentID;
+                    }
+                }
+            });
+        }), Object.keys(aggregatedStats).map(function(key) {
+            return Object.assign({}, aggregatedStats[key], {
+                instanceCount: Object.keys(affectedIDs[key]).length
+            });
+        }).sort(function(a, b) {
+            return b.inclusiveRenderDuration - a.inclusiveRenderDuration;
+        });
+    }
+    function getOperations() {
+        var flushHistory = arguments.length > 0 && void 0 !== arguments[0] ? arguments[0] : getLastMeasurements(), stats = [];
+        return flushHistory.forEach(function(flush, flushIndex) {
+            var operations = flush.operations, treeSnapshot = flush.treeSnapshot;
+            operations.forEach(function(operation) {
+                var instanceID = operation.instanceID, type = operation.type, payload = operation.payload, _treeSnapshot$instanc3 = treeSnapshot[instanceID], displayName = _treeSnapshot$instanc3.displayName, ownerID = _treeSnapshot$instanc3.ownerID, owner = treeSnapshot[ownerID], key = (owner ? owner.displayName + " > " : "") + displayName;
+                stats.push({
+                    flushIndex: flushIndex,
+                    instanceID: instanceID,
+                    key: key,
+                    type: type,
+                    ownerID: ownerID,
+                    payload: payload
+                });
+            });
+        }), stats;
+    }
+    function printExclusive(flushHistory) {
+        consoleTable(getExclusive(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, totalDuration = item.totalDuration, renderCount = item.counts.render || 0, renderDuration = item.durations.render || 0;
+            return {
+                Component: key,
+                "Total time (ms)": roundFloat(totalDuration),
+                "Instance count": instanceCount,
+                "Total render time (ms)": roundFloat(renderDuration),
+                "Average render time (ms)": renderCount ? roundFloat(renderDuration / renderCount) : void 0,
+                "Render count": renderCount,
+                "Total lifecycle time (ms)": roundFloat(totalDuration - renderDuration)
+            };
+        }));
+    }
+    function printInclusive(flushHistory) {
+        consoleTable(getInclusive(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
+            return {
+                "Owner > Component": key,
+                "Inclusive render time (ms)": roundFloat(inclusiveRenderDuration),
+                "Instance count": instanceCount,
+                "Render count": renderCount
+            };
+        }));
+    }
+    function printWasted(flushHistory) {
+        consoleTable(getWasted(flushHistory).map(function(item) {
+            var key = item.key, instanceCount = item.instanceCount, inclusiveRenderDuration = item.inclusiveRenderDuration, renderCount = item.renderCount;
+            return {
+                "Owner > Component": key,
+                "Inclusive wasted time (ms)": roundFloat(inclusiveRenderDuration),
+                "Instance count": instanceCount,
+                "Render count": renderCount
+            };
+        }));
+    }
+    function printOperations(flushHistory) {
+        consoleTable(getOperations(flushHistory).map(function(stat) {
+            return {
+                "Owner > Node": stat.key,
+                Operation: stat.type,
+                Payload: "object" == typeof stat.payload ? JSON.stringify(stat.payload) : stat.payload,
+                "Flush index": stat.flushIndex,
+                "Owner Component ID": stat.ownerID,
+                "DOM Component ID": stat.instanceID
+            };
+        }));
+    }
+    var warnedAboutPrintDOM = !1;
+    function printDOM(measurements) {
+        return lowPriorityWarning_1(warnedAboutPrintDOM, "`ReactPerf.printDOM(...)` is deprecated. Use " + "`ReactPerf.printOperations(...)` instead."), 
+        warnedAboutPrintDOM = !0, printOperations(measurements);
+    }
+    var warnedAboutGetMeasurementsSummaryMap = !1;
+    function getMeasurementsSummaryMap(measurements) {
+        return lowPriorityWarning_1(warnedAboutGetMeasurementsSummaryMap, "`ReactPerf.getMeasurementsSummaryMap(...)` is deprecated. Use " + "`ReactPerf.getWasted(...)` instead."), 
+        warnedAboutGetMeasurementsSummaryMap = !0, getWasted(measurements);
+    }
+    function start() {
+        ReactDebugTool_1.beginProfiling();
+    }
+    function stop() {
+        ReactDebugTool_1.endProfiling();
+    }
+    function isRunning() {
+        return ReactDebugTool_1.isProfiling();
+    }
+    var ReactPerfAnalysis = {
+        getLastMeasurements: getLastMeasurements,
+        getExclusive: getExclusive,
+        getInclusive: getInclusive,
+        getWasted: getWasted,
+        getOperations: getOperations,
+        printExclusive: printExclusive,
+        printInclusive: printInclusive,
+        printWasted: printWasted,
+        printOperations: printOperations,
+        start: start,
+        stop: stop,
+        isRunning: isRunning,
+        printDOM: printDOM,
+        getMeasurementsSummaryMap: getMeasurementsSummaryMap
+    }, ReactPerf = ReactPerfAnalysis, render = function(element, mountInto, callback) {
+        return ReactNativeMount_1.renderComponent(element, mountInto, callback);
+    }, ReactNativeStack = {
+        NativeComponent: ReactNativeComponent_1,
+        hasReactNativeInitialized: !1,
+        findNodeHandle: findNumericNodeHandleStack,
+        render: render,
+        unmountComponentAtNode: ReactNativeMount_1.unmountComponentAtNode,
+        unstable_batchedUpdates: ReactUpdates_1.batchedUpdates,
+        unmountComponentAtNodeAndRemoveContainer: ReactNativeMount_1.unmountComponentAtNodeAndRemoveContainer,
+        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
+            NativeMethodsMixin: NativeMethodsMixin_1,
+            ReactGlobalSharedState: ReactGlobalSharedState_1,
+            ReactNativeComponentTree: ReactNativeComponentTree_1,
+            ReactNativePropRegistry: ReactNativePropRegistry_1,
+            TouchHistoryMath: TouchHistoryMath_1,
+            createReactNativeComponentClass: createReactNativeComponentClass,
+            takeSnapshot: takeSnapshot_1
+        }
+    };
+    Object.assign(ReactNativeStack.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
+        ReactDebugTool: ReactDebugTool_1,
+        ReactPerf: ReactPerf
+    }), "undefined" != typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" == typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject && __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({
+        ComponentTree: {
+            getClosestInstanceFromNode: function(node) {
+                return ReactNativeComponentTree_1.getClosestInstanceFromNode(node);
+            },
+            getNodeFromInstance: function(inst) {
+                for (;inst._renderedComponent; ) inst = inst._renderedComponent;
+                return inst ? ReactNativeComponentTree_1.getNodeFromInstance(inst) : null;
+            }
+        },
+        Mount: ReactNativeMount_1,
+        Reconciler: ReactReconciler_1,
+        getInspectorDataForViewTag: ReactNativeStackInspector.getInspectorDataForViewTag
+    });
+    var ReactNativeStackEntry = ReactNativeStack;
+    module.exports = ReactNativeStackEntry;
+}();
diff --git a/Libraries/Renderer/ReactNativeStack-prod.js b/Libraries/Renderer/ReactNativeStack-prod.js
index f4c056967b2..bbb797490e2 100644
--- a/Libraries/Renderer/ReactNativeStack-prod.js
+++ b/Libraries/Renderer/ReactNativeStack-prod.js
@@ -11,15 +11,15 @@
  */
 "use strict";
 
-var invariant = require("fbjs/lib/invariant");
-
-require("InitializeCore");
-
-var warning = require("fbjs/lib/warning"), RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), UIManager = require("UIManager"), React = require("react"), emptyObject = require("fbjs/lib/emptyObject");
+var invariant = require("fbjs/lib/invariant"), React = require("react"), emptyObject = require("fbjs/lib/emptyObject"), warning = require("fbjs/lib/warning"), UIManager = require("UIManager");
 
 require("prop-types/checkPropTypes");
 
-var shallowEqual = require("fbjs/lib/shallowEqual"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState");
+var shallowEqual = require("fbjs/lib/shallowEqual");
+
+require("InitializeCore");
+
+var RCTEventEmitter = require("RCTEventEmitter"), emptyFunction = require("fbjs/lib/emptyFunction"), deepDiffer = require("deepDiffer"), flattenStyle = require("flattenStyle"), TextInputState = require("TextInputState");
 
 require("deepFreezeAndThrowOnMutationInDev");
 
@@ -75,512 +75,15 @@ var ReactNativeComponentTree = {
     uncacheNode: uncacheNode,
     getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode,
     updateFiberProps: updateFiberProps
-}, ReactNativeComponentTree_1 = ReactNativeComponentTree, eventPluginOrder = null, namesToPlugins = {};
+}, ReactNativeComponentTree_1 = ReactNativeComponentTree;
 
-function recomputePluginOrdering() {
-    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
-        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
-        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
-        !EventPluginRegistry.plugins[pluginIndex]) {
-            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
-            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
-            var publishedEvents = pluginModule.eventTypes;
-            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
-        }
-    }
+function ReactNativeContainerInfo(tag) {
+    return {
+        _tag: tag
+    };
 }
 
-function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
-    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
-    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
-    if (phasedRegistrationNames) {
-        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
-            var phasedRegistrationName = phasedRegistrationNames[phaseName];
-            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
-        }
-        return !0;
-    }
-    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
-    !0);
-}
-
-function publishRegistrationName(registrationName, pluginModule, eventName) {
-    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
-    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
-}
-
-var EventPluginRegistry = {
-    plugins: [],
-    eventNameDispatchConfigs: {},
-    registrationNameModules: {},
-    registrationNameDependencies: {},
-    possibleRegistrationNames: null,
-    injectEventPluginOrder: function(injectedEventPluginOrder) {
-        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
-        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
-    },
-    injectEventPluginsByName: function(injectedNamesToPlugins) {
-        var isOrderingDirty = !1;
-        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
-            var pluginModule = injectedNamesToPlugins[pluginName];
-            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
-            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
-        }
-        isOrderingDirty && recomputePluginOrdering();
-    }
-}, EventPluginRegistry_1 = EventPluginRegistry, caughtError = null, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
-    var funcArgs = Array.prototype.slice.call(arguments, 3);
-    try {
-        func.apply(context, funcArgs);
-    } catch (error) {
-        return error;
-    }
-    return null;
-}, rethrowCaughtError = function() {
-    if (caughtError) {
-        var error = caughtError;
-        throw caughtError = null, error;
-    }
-}, ReactErrorUtils = {
-    injection: {
-        injectErrorUtils: function(injectedErrorUtils) {
-            invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
-            invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
-        }
-    },
-    invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
-        return invokeGuardedCallback.apply(this, arguments);
-    },
-    invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
-        var error = ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);
-        null !== error && null === caughtError && (caughtError = error);
-    },
-    rethrowCaughtError: function() {
-        return rethrowCaughtError.apply(this, arguments);
-    }
-}, ReactErrorUtils_1 = ReactErrorUtils, ComponentTree, injection = {
-    injectComponentTree: function(Injected) {
-        ComponentTree = Injected;
-    }
-};
-
-function isEndish(topLevelType) {
-    return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
-}
-
-function isMoveish(topLevelType) {
-    return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
-}
-
-function isStartish(topLevelType) {
-    return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
-}
-
-function executeDispatch(event, simulated, listener, inst) {
-    var type = event.type || "unknown-event";
-    event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
-    event.currentTarget = null;
-}
-
-function executeDispatchesInOrder(event, simulated) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
-    event._dispatchListeners = null, event._dispatchInstances = null;
-}
-
-function executeDispatchesInOrderStopAtTrueImpl(event) {
-    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
-    if (Array.isArray(dispatchListeners)) {
-        for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
-    } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
-    return null;
-}
-
-function executeDispatchesInOrderStopAtTrue(event) {
-    var ret = executeDispatchesInOrderStopAtTrueImpl(event);
-    return event._dispatchInstances = null, event._dispatchListeners = null, ret;
-}
-
-function executeDirectDispatch(event) {
-    var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
-    invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
-    event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
-    var res = dispatchListener ? dispatchListener(event) : null;
-    return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
-    res;
-}
-
-function hasDispatches(event) {
-    return !!event._dispatchListeners;
-}
-
-var EventPluginUtils = {
-    isEndish: isEndish,
-    isMoveish: isMoveish,
-    isStartish: isStartish,
-    executeDirectDispatch: executeDirectDispatch,
-    executeDispatchesInOrder: executeDispatchesInOrder,
-    executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
-    hasDispatches: hasDispatches,
-    getFiberCurrentPropsFromNode: function(node) {
-        return ComponentTree.getFiberCurrentPropsFromNode(node);
-    },
-    getInstanceFromNode: function(node) {
-        return ComponentTree.getInstanceFromNode(node);
-    },
-    getNodeFromInstance: function(node) {
-        return ComponentTree.getNodeFromInstance(node);
-    },
-    injection: injection
-}, EventPluginUtils_1 = EventPluginUtils;
-
-function accumulateInto(current, next) {
-    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
-    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulateInto_1 = accumulateInto;
-
-function forEachAccumulated(arr, cb, scope) {
-    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
-}
-
-var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
-    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
-}, executeDispatchesAndReleaseSimulated = function(e) {
-    return executeDispatchesAndRelease(e, !0);
-}, executeDispatchesAndReleaseTopLevel = function(e) {
-    return executeDispatchesAndRelease(e, !1);
-};
-
-function isInteractive(tag) {
-    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
-}
-
-function shouldPreventMouseEvent(name, type, props) {
-    switch (name) {
-      case "onClick":
-      case "onClickCapture":
-      case "onDoubleClick":
-      case "onDoubleClickCapture":
-      case "onMouseDown":
-      case "onMouseDownCapture":
-      case "onMouseMove":
-      case "onMouseMoveCapture":
-      case "onMouseUp":
-      case "onMouseUpCapture":
-        return !(!props.disabled || !isInteractive(type));
-
-      default:
-        return !1;
-    }
-}
-
-var EventPluginHub = {
-    injection: {
-        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
-        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
-    },
-    getListener: function(inst, registrationName) {
-        var listener;
-        if ("number" == typeof inst.tag) {
-            var stateNode = inst.stateNode;
-            if (!stateNode) return null;
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
-            if (!props) return null;
-            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
-        } else {
-            var currentElement = inst._currentElement;
-            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
-            if (!inst._rootNodeID) return null;
-            var _props = currentElement.props;
-            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
-        }
-        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
-        listener;
-    },
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
-            var possiblePlugin = plugins[i];
-            if (possiblePlugin) {
-                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
-                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
-            }
-        }
-        return events;
-    },
-    enqueueEvents: function(events) {
-        events && (eventQueue = accumulateInto_1(eventQueue, events));
-    },
-    processEventQueue: function(simulated) {
-        var processingEventQueue = eventQueue;
-        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
-        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
-        ReactErrorUtils_1.rethrowCaughtError();
-    }
-}, EventPluginHub_1 = EventPluginHub, ReactTypeOfWork = {
-    IndeterminateComponent: 0,
-    FunctionalComponent: 1,
-    ClassComponent: 2,
-    HostRoot: 3,
-    HostPortal: 4,
-    HostComponent: 5,
-    HostText: 6,
-    CoroutineComponent: 7,
-    CoroutineHandlerPhase: 8,
-    YieldComponent: 9,
-    Fragment: 10
-}, HostComponent = ReactTypeOfWork.HostComponent;
-
-function getParent(inst) {
-    if (void 0 !== inst._hostParent) return inst._hostParent;
-    if ("number" == typeof inst.tag) {
-        do {
-            inst = inst.return;
-        } while (inst && inst.tag !== HostComponent);
-        if (inst) return inst;
-    }
-    return null;
-}
-
-function getLowestCommonAncestor(instA, instB) {
-    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
-    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
-    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
-    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
-    for (var depth = depthA; depth--; ) {
-        if (instA === instB || instA === instB.alternate) return instA;
-        instA = getParent(instA), instB = getParent(instB);
-    }
-    return null;
-}
-
-function isAncestor(instA, instB) {
-    for (;instB; ) {
-        if (instA === instB || instA === instB.alternate) return !0;
-        instB = getParent(instB);
-    }
-    return !1;
-}
-
-function getParentInstance(inst) {
-    return getParent(inst);
-}
-
-function traverseTwoPhase(inst, fn, arg) {
-    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
-    var i;
-    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
-    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
-}
-
-function traverseEnterLeave(from, to, fn, argFrom, argTo) {
-    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
-    from = getParent(from);
-    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
-    var i;
-    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
-    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
-}
-
-var ReactTreeTraversal = {
-    isAncestor: isAncestor,
-    getLowestCommonAncestor: getLowestCommonAncestor,
-    getParentInstance: getParentInstance,
-    traverseTwoPhase: traverseTwoPhase,
-    traverseEnterLeave: traverseEnterLeave
-}, getListener = EventPluginHub_1.getListener;
-
-function listenerAtPhase(inst, event, propagationPhase) {
-    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
-    return getListener(inst, registrationName);
-}
-
-function accumulateDirectionalDispatches(inst, phase, event) {
-    var listener = listenerAtPhase(inst, event, phase);
-    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-}
-
-function accumulateTwoPhaseDispatchesSingle(event) {
-    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
-}
-
-function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
-    if (event && event.dispatchConfig.phasedRegistrationNames) {
-        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
-        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
-    }
-}
-
-function accumulateDispatches(inst, ignoredDirection, event) {
-    if (inst && event && event.dispatchConfig.registrationName) {
-        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
-        listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
-        event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
-    }
-}
-
-function accumulateDirectDispatchesSingle(event) {
-    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
-}
-
-function accumulateTwoPhaseDispatches(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
-}
-
-function accumulateTwoPhaseDispatchesSkipTarget(events) {
-    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
-}
-
-function accumulateEnterLeaveDispatches(leave, enter, from, to) {
-    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
-}
-
-function accumulateDirectDispatches(events) {
-    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
-}
-
-var EventPropagators = {
-    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
-    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
-    accumulateDirectDispatches: accumulateDirectDispatches,
-    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
-}, EventPropagators_1 = EventPropagators, oneArgumentPooler = function(copyFieldsFrom) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, copyFieldsFrom), instance;
-    }
-    return new Klass(copyFieldsFrom);
-}, twoArgumentPooler = function(a1, a2) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2), instance;
-    }
-    return new Klass(a1, a2);
-}, threeArgumentPooler = function(a1, a2, a3) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3), instance;
-    }
-    return new Klass(a1, a2, a3);
-}, fourArgumentPooler = function(a1, a2, a3, a4) {
-    var Klass = this;
-    if (Klass.instancePool.length) {
-        var instance = Klass.instancePool.pop();
-        return Klass.call(instance, a1, a2, a3, a4), instance;
-    }
-    return new Klass(a1, a2, a3, a4);
-}, standardReleaser = function(instance) {
-    var Klass = this;
-    invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
-    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
-}, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
-    var NewKlass = CopyConstructor;
-    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
-    NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
-    NewKlass;
-}, PooledClass = {
-    addPoolingTo: addPoolingTo,
-    oneArgumentPooler: oneArgumentPooler,
-    twoArgumentPooler: twoArgumentPooler,
-    threeArgumentPooler: threeArgumentPooler,
-    fourArgumentPooler: fourArgumentPooler
-}, PooledClass_1 = PooledClass, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
-    type: null,
-    target: null,
-    currentTarget: emptyFunction.thatReturnsNull,
-    eventPhase: null,
-    bubbles: null,
-    cancelable: null,
-    timeStamp: function(event) {
-        return event.timeStamp || Date.now();
-    },
-    defaultPrevented: null,
-    isTrusted: null
-};
-
-function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
-    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
-    var Interface = this.constructor.Interface;
-    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
-        var normalize = Interface[propName];
-        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
-    }
-    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
-    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
-    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
-}
-
-Object.assign(SyntheticEvent.prototype, {
-    preventDefault: function() {
-        this.defaultPrevented = !0;
-        var event = this.nativeEvent;
-        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
-        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
-    },
-    stopPropagation: function() {
-        var event = this.nativeEvent;
-        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
-        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
-    },
-    persist: function() {
-        this.isPersistent = emptyFunction.thatReturnsTrue;
-    },
-    isPersistent: emptyFunction.thatReturnsFalse,
-    destructor: function() {
-        var Interface = this.constructor.Interface;
-        for (var propName in Interface) this[propName] = null;
-        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
-    }
-}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
-    var Super = this, E = function() {};
-    E.prototype = Super.prototype;
-    var prototype = new E();
-    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
-    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
-    PooledClass_1.addPoolingTo(Class, PooledClass_1.fourArgumentPooler);
-}, PooledClass_1.addPoolingTo(SyntheticEvent, PooledClass_1.fourArgumentPooler);
-
-var SyntheticEvent_1 = SyntheticEvent, _extends = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
-
-for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
-
-for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
-allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
-
-var ReactNativeBridgeEventPlugin = {
-    eventTypes: _extends({}, customBubblingEventTypes, customDirectEventTypes),
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
-        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
-            if (!directDispatchConfig) return null;
-            EventPropagators_1.accumulateDirectDispatches(event);
-        }
-        return event;
-    }
-}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
-
-function runEventQueueInBatch(events) {
-    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
-}
-
-var ReactEventEmitterMixin = {
-    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
-    }
-}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
+var ReactNativeContainerInfo_1 = ReactNativeContainerInfo, INITIAL_TAG_COUNT = 1, ReactNativeTagHandles = {
     tagsStartAt: INITIAL_TAG_COUNT,
     tagCount: INITIAL_TAG_COUNT,
     allocateTag: function() {
@@ -594,388 +97,19 @@ var ReactEventEmitterMixin = {
     reactTagIsNativeTopRootID: function(reactTag) {
         return reactTag % 10 == 1;
     }
-}, ReactNativeTagHandles_1 = ReactNativeTagHandles, fiberHostComponent = null, ReactControlledComponentInjection = {
-    injectFiberControlledHostComponent: function(hostComponentImpl) {
-        fiberHostComponent = hostComponentImpl;
-    }
-}, restoreTarget = null, restoreQueue = null;
-
-function restoreStateOfTarget(target) {
-    var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
-    if (internalInstance) {
-        if ("number" == typeof internalInstance.tag) {
-            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "Fiber needs to be injected to handle a fiber target for controlled " + "events.");
-            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
-            return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
-        }
-        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component."), 
-        internalInstance.restoreControlledState();
-    }
-}
-
-var ReactControlledComponent = {
-    injection: ReactControlledComponentInjection,
-    enqueueStateRestore: function(target) {
-        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
-    },
-    restoreStateIfNeeded: function() {
-        if (restoreTarget) {
-            var target = restoreTarget, queuedTargets = restoreQueue;
-            if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
-        }
-    }
-}, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
-    return fn(a, b, c, d, e);
-}, fiberBatchedUpdates = function(fn, bookkeeping) {
-    return fn(bookkeeping);
-};
-
-function performFiberBatchedUpdates(fn, bookkeeping) {
-    return fiberBatchedUpdates(fn, bookkeeping);
-}
-
-function batchedUpdates(fn, bookkeeping) {
-    return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
-}
-
-var isNestingBatched = !1;
-
-function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
-    if (isNestingBatched) return batchedUpdates(fn, bookkeeping);
-    isNestingBatched = !0;
-    try {
-        return batchedUpdates(fn, bookkeeping);
-    } finally {
-        isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
-    }
-}
-
-var ReactGenericBatchingInjection = {
-    injectStackBatchedUpdates: function(_batchedUpdates) {
-        stackBatchedUpdates = _batchedUpdates;
-    },
-    injectFiberBatchedUpdates: function(_batchedUpdates) {
-        fiberBatchedUpdates = _batchedUpdates;
-    }
-}, ReactGenericBatching = {
-    batchedUpdates: batchedUpdatesWithControlledComponents,
-    injection: ReactGenericBatchingInjection
-}, ReactGenericBatching_1 = ReactGenericBatching, _extends$1 = Object.assign || function(target) {
-    for (var i = 1; i < arguments.length; i++) {
-        var source = arguments[i];
-        for (var key in source) Object.prototype.hasOwnProperty.call(source, key) && (target[key] = source[key]);
-    }
-    return target;
-}, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
-    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
-    return ret;
-}, removeTouchesAtIndices = function(touches, indices) {
-    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
-        var index = indices[i];
-        rippedOut.push(touches[index]), temp[index] = null;
-    }
-    for (var fillAt = 0, j = 0; j < temp.length; j++) {
-        var cur = temp[j];
-        null !== cur && (temp[fillAt++] = cur);
-    }
-    return temp.length = fillAt, rippedOut;
-}, ReactNativeEventEmitter = _extends$1({}, ReactEventEmitterMixin_1, {
-    registrationNames: EventPluginRegistry_1.registrationNameModules,
-    getListener: EventPluginHub_1.getListener,
-    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
-        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
-        ReactGenericBatching_1.batchedUpdates(function() {
-            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
-        });
-    },
-    receiveEvent: function(tag, topLevelType, nativeEventParam) {
-        var rootNodeID = tag;
-        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
-    },
-    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
-        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
-            var touch = changedTouches[jj];
-            touch.changedTouches = changedTouches, touch.touches = touches;
-            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
-            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt || (rootNodeID = target)), 
-            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
-        }
-    }
-}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
-    onChange: function(from, to, blockNativeResponder) {
-        if (null !== to) {
-            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
-            UIManager.setJSResponder(tag, blockNativeResponder);
-        } else UIManager.clearJSResponder();
-    }
-}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
-    touchHistory: function(nativeEvent) {
-        return null;
-    }
-};
-
-function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
-    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
-}
-
-SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
-
-var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
-    touchBank: touchBank,
-    numberActiveTouches: 0,
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0
-};
-
-function timestampForTouch(touch) {
-    return touch.timeStamp || touch.timestamp;
-}
-
-function createTouchRecord(touch) {
-    return {
-        touchActive: !0,
-        startPageX: touch.pageX,
-        startPageY: touch.pageY,
-        startTimeStamp: timestampForTouch(touch),
-        currentPageX: touch.pageX,
-        currentPageY: touch.pageY,
-        currentTimeStamp: timestampForTouch(touch),
-        previousPageX: touch.pageX,
-        previousPageY: touch.pageY,
-        previousTimeStamp: timestampForTouch(touch)
-    };
-}
-
-function resetTouchRecord(touchRecord, touch) {
-    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
-    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
-    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
-    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
-    touchRecord.previousTimeStamp = timestampForTouch(touch);
-}
-
-function getTouchIdentifier(_ref) {
-    var identifier = _ref.identifier;
-    return invariant(null != identifier, "Touch object is missing identifier."), warning(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
-    identifier;
-}
-
-function recordTouchStart(touch) {
-    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
-    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
-    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-}
-
-function recordTouchMove(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function recordTouchEnd(touch) {
-    var touchRecord = touchBank[getTouchIdentifier(touch)];
-    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
-    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
-    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
-    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
-}
-
-function printTouch(touch) {
-    return JSON.stringify({
-        identifier: touch.identifier,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        timestamp: timestampForTouch(touch)
-    });
-}
-
-function printTouchBank() {
-    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
-    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
-    printed;
-}
-
-var ResponderTouchHistoryStore = {
-    recordTouchTrack: function(topLevelType, nativeEvent) {
-        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
-        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) for (var i = 0; i < touchBank.length; i++) {
-            var touchTrackToCheck = touchBank[i];
-            if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
-                touchHistory.indexOfSingleActiveTouch = i;
-                break;
-            }
-        }
-    },
-    touchHistory: touchHistory
-}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
-
-function accumulate(current, next) {
-    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
-    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
-}
-
-var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
-    var oldResponderInst = responderInst;
-    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
-}, eventTypes = {
-    startShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onStartShouldSetResponder",
-            captured: "onStartShouldSetResponderCapture"
-        }
-    },
-    scrollShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onScrollShouldSetResponder",
-            captured: "onScrollShouldSetResponderCapture"
-        }
-    },
-    selectionChangeShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onSelectionChangeShouldSetResponder",
-            captured: "onSelectionChangeShouldSetResponderCapture"
-        }
-    },
-    moveShouldSetResponder: {
-        phasedRegistrationNames: {
-            bubbled: "onMoveShouldSetResponder",
-            captured: "onMoveShouldSetResponderCapture"
-        }
-    },
-    responderStart: {
-        registrationName: "onResponderStart"
-    },
-    responderMove: {
-        registrationName: "onResponderMove"
-    },
-    responderEnd: {
-        registrationName: "onResponderEnd"
-    },
-    responderRelease: {
-        registrationName: "onResponderRelease"
-    },
-    responderTerminationRequest: {
-        registrationName: "onResponderTerminationRequest"
-    },
-    responderGrant: {
-        registrationName: "onResponderGrant"
-    },
-    responderReject: {
-        registrationName: "onResponderReject"
-    },
-    responderTerminate: {
-        registrationName: "onResponderTerminate"
-    }
-};
-
-function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
-    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
-    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
-    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
-    !wantsResponderInst || wantsResponderInst === responderInst) return null;
-    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
-    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
-    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
-    if (responderInst) {
-        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
-        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
-        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
-        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
-        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
-        shouldSwitch) {
-            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
-            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
-            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
-        } else {
-            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
-            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
-            extracted = accumulate_1(extracted, rejectEvent);
-        }
-    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
-    return extracted;
-}
-
-function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
-    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
-}
-
-function noResponderTouches(nativeEvent) {
-    var touches = nativeEvent.touches;
-    if (!touches || 0 === touches.length) return !0;
-    for (var i = 0; i < touches.length; i++) {
-        var activeTouch = touches[i], target = activeTouch.target;
-        if (null !== target && void 0 !== target && 0 !== target) {
-            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
-            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
-        }
-    }
-    return !0;
-}
-
-var ResponderEventPlugin = {
-    _getResponder: function() {
-        return responderInst;
-    },
-    eventTypes: eventTypes,
-    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
-        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
-            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
-            null;
-            trackedTouchCount -= 1;
-        }
-        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
-        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
-        if (incrementalTouch) {
-            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
-            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
-            extracted = accumulate_1(extracted, gesture);
-        }
-        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
-        if (finalTouch) {
-            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
-            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
-            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
-        }
-        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
-        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
-        previousActiveTouches = numberActiveTouches, extracted;
-    },
-    GlobalResponderHandler: null,
-    GlobalInteractionHandler: null,
-    injection: {
-        injectGlobalResponderHandler: function(GlobalResponderHandler) {
-            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
-        },
-        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
-            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
-        }
-    }
-}, ResponderEventPlugin_1 = ResponderEventPlugin;
-
-function inject() {
-    RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
-    EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
-    EventPluginHub_1.injection.injectEventPluginsByName({
-        ResponderEventPlugin: ResponderEventPlugin_1,
-        ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
-    });
-}
-
-var ReactNativeInjection = {
-    inject: inject
-};
-
-function ReactNativeContainerInfo(tag) {
-    return {
-        _tag: tag
-    };
-}
-
-var ReactNativeContainerInfo_1 = ReactNativeContainerInfo, ClassComponent = ReactTypeOfWork.ClassComponent;
+}, ReactNativeTagHandles_1 = ReactNativeTagHandles, ReactTypeOfWork = {
+    IndeterminateComponent: 0,
+    FunctionalComponent: 1,
+    ClassComponent: 2,
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5,
+    HostText: 6,
+    CoroutineComponent: 7,
+    CoroutineHandlerPhase: 8,
+    YieldComponent: 9,
+    Fragment: 10
+}, ClassComponent = ReactTypeOfWork.ClassComponent;
 
 function isValidOwner(object) {
     return !(!object || "function" != typeof object.attachRef || "function" != typeof object.detachRef);
@@ -1071,7 +205,50 @@ var ReactReconciler = {
     set: function(key, value) {
         key._reactInternalInstance = value;
     }
-}, ReactInstanceMap_1 = ReactInstanceMap, OBSERVED_ERROR = {}, TransactionImpl = {
+}, ReactInstanceMap_1 = ReactInstanceMap, oneArgumentPooler = function(copyFieldsFrom) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+        var instance = Klass.instancePool.pop();
+        return Klass.call(instance, copyFieldsFrom), instance;
+    }
+    return new Klass(copyFieldsFrom);
+}, twoArgumentPooler = function(a1, a2) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+        var instance = Klass.instancePool.pop();
+        return Klass.call(instance, a1, a2), instance;
+    }
+    return new Klass(a1, a2);
+}, threeArgumentPooler = function(a1, a2, a3) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+        var instance = Klass.instancePool.pop();
+        return Klass.call(instance, a1, a2, a3), instance;
+    }
+    return new Klass(a1, a2, a3);
+}, fourArgumentPooler = function(a1, a2, a3, a4) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+        var instance = Klass.instancePool.pop();
+        return Klass.call(instance, a1, a2, a3, a4), instance;
+    }
+    return new Klass(a1, a2, a3, a4);
+}, standardReleaser = function(instance) {
+    var Klass = this;
+    invariant(instance instanceof Klass, "Trying to release an instance into a pool of a different type."), 
+    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
+}, DEFAULT_POOL_SIZE = 10, DEFAULT_POOLER = oneArgumentPooler, addPoolingTo = function(CopyConstructor, pooler) {
+    var NewKlass = CopyConstructor;
+    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, 
+    NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, 
+    NewKlass;
+}, PooledClass = {
+    addPoolingTo: addPoolingTo,
+    oneArgumentPooler: oneArgumentPooler,
+    twoArgumentPooler: twoArgumentPooler,
+    threeArgumentPooler: threeArgumentPooler,
+    fourArgumentPooler: fourArgumentPooler
+}, PooledClass_1 = PooledClass, OBSERVED_ERROR = {}, TransactionImpl = {
     reinitializeTransaction: function() {
         this.transactionWrappers = this.getTransactionWrappers(), this.wrapperInitData ? this.wrapperInitData.length = 0 : this.wrapperInitData = [], 
         this._isInTransaction = !1;
@@ -1158,7 +335,7 @@ Object.assign(ReactUpdatesFlushTransaction.prototype, Transaction, {
     }
 }), PooledClass_1.addPoolingTo(ReactUpdatesFlushTransaction);
 
-function batchedUpdates$1(callback, a, b, c, d, e) {
+function batchedUpdates(callback, a, b, c, d, e) {
     return ensureInjected(), batchingStrategy.batchedUpdates(callback, a, b, c, d, e);
 }
 
@@ -1204,7 +381,7 @@ var ReactUpdatesInjection = {
     }
 }, ReactUpdates = {
     ReactReconcileTransaction: null,
-    batchedUpdates: batchedUpdates$1,
+    batchedUpdates: batchedUpdates,
     enqueueUpdate: enqueueUpdate$1,
     flushBatchedUpdates: flushBatchedUpdates,
     injection: ReactUpdatesInjection
@@ -1268,7 +445,55 @@ var ReactUpdateQueue = {
     ImpureClass: 0,
     PureClass: 1,
     StatelessFunctional: 2
-}, ReactNodeTypes = {
+}, ReactErrorUtils = {
+    _caughtError: null,
+    _hasCaughtError: !1,
+    _rethrowError: null,
+    _hasRethrowError: !1,
+    injection: {
+        injectErrorUtils: function(injectedErrorUtils) {
+            invariant("function" == typeof injectedErrorUtils.invokeGuardedCallback, "Injected invokeGuardedCallback() must be a function."), 
+            invokeGuardedCallback = injectedErrorUtils.invokeGuardedCallback;
+        }
+    },
+    invokeGuardedCallback: function(name, func, context, a, b, c, d, e, f) {
+        invokeGuardedCallback.apply(ReactErrorUtils, arguments);
+    },
+    invokeGuardedCallbackAndCatchFirstError: function(name, func, context, a, b, c, d, e, f) {
+        if (ReactErrorUtils.invokeGuardedCallback.apply(this, arguments), ReactErrorUtils.hasCaughtError()) {
+            var error = ReactErrorUtils.clearCaughtError();
+            ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
+        }
+    },
+    rethrowCaughtError: function() {
+        return rethrowCaughtError.apply(ReactErrorUtils, arguments);
+    },
+    hasCaughtError: function() {
+        return ReactErrorUtils._hasCaughtError;
+    },
+    clearCaughtError: function() {
+        if (ReactErrorUtils._hasCaughtError) {
+            var error = ReactErrorUtils._caughtError;
+            return ReactErrorUtils._caughtError = null, ReactErrorUtils._hasCaughtError = !1, 
+            error;
+        }
+        invariant(!1, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
+    }
+}, invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
+    ReactErrorUtils._hasCaughtError = !1, ReactErrorUtils._caughtError = null;
+    var funcArgs = Array.prototype.slice.call(arguments, 3);
+    try {
+        func.apply(context, funcArgs);
+    } catch (error) {
+        ReactErrorUtils._caughtError = error, ReactErrorUtils._hasCaughtError = !0;
+    }
+}, rethrowCaughtError = function() {
+    if (ReactErrorUtils._hasRethrowError) {
+        var error = ReactErrorUtils._rethrowError;
+        throw ReactErrorUtils._rethrowError = null, ReactErrorUtils._hasRethrowError = !1, 
+        error;
+    }
+}, ReactErrorUtils_1 = ReactErrorUtils, ReactNodeTypes = {
     HOST: 0,
     COMPOSITE: 1,
     EMPTY: 2,
@@ -1323,7 +548,7 @@ var nextMountID = 1, ReactCompositeComponent = {
         this._pendingStateQueue = null, this._pendingReplaceState = !1, this._pendingForceUpdate = !1, 
         inst.componentWillMount && (inst.componentWillMount(), this._pendingStateQueue && (inst.state = this._processPendingState(inst.props, inst.context)));
         var markup;
-        markup = inst.unstable_handleError ? this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context) : this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context), 
+        markup = inst.componentDidCatch ? this.performInitialMountWithErrorHandling(renderedElement, hostParent, hostContainerInfo, transaction, context) : this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context), 
         inst.componentDidMount && transaction.getReactMountReady().enqueue(inst.componentDidMount, inst);
         var callbacks = this._pendingCallbacks;
         if (callbacks) {
@@ -1344,7 +569,7 @@ var nextMountID = 1, ReactCompositeComponent = {
         try {
             markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
         } catch (e) {
-            transaction.rollback(checkpoint), this._instance.unstable_handleError(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
+            transaction.rollback(checkpoint), this._instance.componentDidCatch(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
             checkpoint = transaction.checkpoint(), this._renderedComponent.unmountComponent(!0, !0), 
             transaction.rollback(checkpoint), markup = this.performInitialMount(renderedElement, hostParent, hostContainerInfo, transaction, context);
         }
@@ -1447,7 +672,7 @@ var nextMountID = 1, ReactCompositeComponent = {
         var prevProps, prevState, inst = this._instance, hasComponentDidUpdate = !!inst.componentDidUpdate;
         hasComponentDidUpdate && (prevProps = inst.props, prevState = inst.state), inst.componentWillUpdate && inst.componentWillUpdate(nextProps, nextState, nextContext), 
         this._currentElement = nextElement, this._context = unmaskedContext, inst.props = nextProps, 
-        inst.state = nextState, inst.context = nextContext, inst.unstable_handleError ? this._updateRenderedComponentWithErrorHandling(transaction, unmaskedContext) : this._updateRenderedComponent(transaction, unmaskedContext), 
+        inst.state = nextState, inst.context = nextContext, inst.componentDidCatch ? this._updateRenderedComponentWithErrorHandling(transaction, unmaskedContext) : this._updateRenderedComponent(transaction, unmaskedContext), 
         hasComponentDidUpdate && transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState), inst);
     },
     _updateRenderedComponentWithErrorHandling: function(transaction, context) {
@@ -1455,7 +680,7 @@ var nextMountID = 1, ReactCompositeComponent = {
         try {
             this._updateRenderedComponent(transaction, context);
         } catch (e) {
-            transaction.rollback(checkpoint), this._instance.unstable_handleError(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
+            transaction.rollback(checkpoint), this._instance.componentDidCatch(e), this._pendingStateQueue && (this._instance.state = this._processPendingState(this._instance.props, this._instance.context)), 
             checkpoint = transaction.checkpoint(), this._updateRenderedComponentWithNextElement(transaction, context, null, !0), 
             this._updateRenderedComponent(transaction, context);
         }
@@ -1661,7 +886,817 @@ var ReactNativeMount = {
     unmountComponentFromNode: function(instance, containerID) {
         ReactReconciler_1.unmountComponent(instance), UIManager.removeSubviewsFromContainerWithID(containerID);
     }
-}, ReactNativeMount_1 = ReactNativeMount, RESET_BATCHED_UPDATES = {
+}, ReactNativeMount_1 = ReactNativeMount, getInspectorDataForViewTag = void 0;
+
+getInspectorDataForViewTag = function() {
+    invariant(!1, "getInspectorDataForViewTag() is not available in production");
+};
+
+var ReactNativeStackInspector = {
+    getInspectorDataForViewTag: getInspectorDataForViewTag
+}, findNumericNodeHandleStack = function(componentOrHandle) {
+    var nodeHandle = findNodeHandle_1(componentOrHandle);
+    return null == nodeHandle || "number" == typeof nodeHandle ? nodeHandle : nodeHandle.getHostNode();
+}, eventPluginOrder = null, namesToPlugins = {};
+
+function recomputePluginOrdering() {
+    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
+        var pluginModule = namesToPlugins[pluginName], pluginIndex = eventPluginOrder.indexOf(pluginName);
+        if (invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName), 
+        !EventPluginRegistry.plugins[pluginIndex]) {
+            invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName), 
+            EventPluginRegistry.plugins[pluginIndex] = pluginModule;
+            var publishedEvents = pluginModule.eventTypes;
+            for (var eventName in publishedEvents) invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
+        }
+    }
+}
+
+function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
+    invariant(!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", eventName), 
+    EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
+    var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
+    if (phasedRegistrationNames) {
+        for (var phaseName in phasedRegistrationNames) if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
+            var phasedRegistrationName = phasedRegistrationNames[phaseName];
+            publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
+        }
+        return !0;
+    }
+    return !!dispatchConfig.registrationName && (publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName), 
+    !0);
+}
+
+function publishRegistrationName(registrationName, pluginModule, eventName) {
+    invariant(!EventPluginRegistry.registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", registrationName), 
+    EventPluginRegistry.registrationNameModules[registrationName] = pluginModule, EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
+}
+
+var EventPluginRegistry = {
+    plugins: [],
+    eventNameDispatchConfigs: {},
+    registrationNameModules: {},
+    registrationNameDependencies: {},
+    possibleRegistrationNames: null,
+    injectEventPluginOrder: function(injectedEventPluginOrder) {
+        invariant(!eventPluginOrder, "EventPluginRegistry: Cannot inject event plugin ordering more than " + "once. You are likely trying to load more than one copy of React."), 
+        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder), recomputePluginOrdering();
+    },
+    injectEventPluginsByName: function(injectedNamesToPlugins) {
+        var isOrderingDirty = !1;
+        for (var pluginName in injectedNamesToPlugins) if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
+            var pluginModule = injectedNamesToPlugins[pluginName];
+            namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName), 
+            namesToPlugins[pluginName] = pluginModule, isOrderingDirty = !0);
+        }
+        isOrderingDirty && recomputePluginOrdering();
+    }
+}, EventPluginRegistry_1 = EventPluginRegistry, ComponentTree, injection = {
+    injectComponentTree: function(Injected) {
+        ComponentTree = Injected;
+    }
+};
+
+function isEndish(topLevelType) {
+    return "topMouseUp" === topLevelType || "topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType;
+}
+
+function isMoveish(topLevelType) {
+    return "topMouseMove" === topLevelType || "topTouchMove" === topLevelType;
+}
+
+function isStartish(topLevelType) {
+    return "topMouseDown" === topLevelType || "topTouchStart" === topLevelType;
+}
+
+function executeDispatch(event, simulated, listener, inst) {
+    var type = event.type || "unknown-event";
+    event.currentTarget = EventPluginUtils.getNodeFromInstance(inst), ReactErrorUtils_1.invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event), 
+    event.currentTarget = null;
+}
+
+function executeDispatchesInOrder(event, simulated) {
+    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+    if (Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]); else dispatchListeners && executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
+    event._dispatchListeners = null, event._dispatchInstances = null;
+}
+
+function executeDispatchesInOrderStopAtTrueImpl(event) {
+    var dispatchListeners = event._dispatchListeners, dispatchInstances = event._dispatchInstances;
+    if (Array.isArray(dispatchListeners)) {
+        for (var i = 0; i < dispatchListeners.length && !event.isPropagationStopped(); i++) if (dispatchListeners[i](event, dispatchInstances[i])) return dispatchInstances[i];
+    } else if (dispatchListeners && dispatchListeners(event, dispatchInstances)) return dispatchInstances;
+    return null;
+}
+
+function executeDispatchesInOrderStopAtTrue(event) {
+    var ret = executeDispatchesInOrderStopAtTrueImpl(event);
+    return event._dispatchInstances = null, event._dispatchListeners = null, ret;
+}
+
+function executeDirectDispatch(event) {
+    var dispatchListener = event._dispatchListeners, dispatchInstance = event._dispatchInstances;
+    invariant(!Array.isArray(dispatchListener), "executeDirectDispatch(...): Invalid `event`."), 
+    event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
+    var res = dispatchListener ? dispatchListener(event) : null;
+    return event.currentTarget = null, event._dispatchListeners = null, event._dispatchInstances = null, 
+    res;
+}
+
+function hasDispatches(event) {
+    return !!event._dispatchListeners;
+}
+
+var EventPluginUtils = {
+    isEndish: isEndish,
+    isMoveish: isMoveish,
+    isStartish: isStartish,
+    executeDirectDispatch: executeDirectDispatch,
+    executeDispatchesInOrder: executeDispatchesInOrder,
+    executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue,
+    hasDispatches: hasDispatches,
+    getFiberCurrentPropsFromNode: function(node) {
+        return ComponentTree.getFiberCurrentPropsFromNode(node);
+    },
+    getInstanceFromNode: function(node) {
+        return ComponentTree.getInstanceFromNode(node);
+    },
+    getNodeFromInstance: function(node) {
+        return ComponentTree.getNodeFromInstance(node);
+    },
+    injection: injection
+}, EventPluginUtils_1 = EventPluginUtils;
+
+function accumulateInto(current, next) {
+    return invariant(null != next, "accumulateInto(...): Accumulated items must not be null or undefined."), 
+    null == current ? next : Array.isArray(current) ? Array.isArray(next) ? (current.push.apply(current, next), 
+    current) : (current.push(next), current) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+}
+
+var accumulateInto_1 = accumulateInto;
+
+function forEachAccumulated(arr, cb, scope) {
+    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
+}
+
+var forEachAccumulated_1 = forEachAccumulated, eventQueue = null, executeDispatchesAndRelease = function(event, simulated) {
+    event && (EventPluginUtils_1.executeDispatchesInOrder(event, simulated), event.isPersistent() || event.constructor.release(event));
+}, executeDispatchesAndReleaseSimulated = function(e) {
+    return executeDispatchesAndRelease(e, !0);
+}, executeDispatchesAndReleaseTopLevel = function(e) {
+    return executeDispatchesAndRelease(e, !1);
+};
+
+function isInteractive(tag) {
+    return "button" === tag || "input" === tag || "select" === tag || "textarea" === tag;
+}
+
+function shouldPreventMouseEvent(name, type, props) {
+    switch (name) {
+      case "onClick":
+      case "onClickCapture":
+      case "onDoubleClick":
+      case "onDoubleClickCapture":
+      case "onMouseDown":
+      case "onMouseDownCapture":
+      case "onMouseMove":
+      case "onMouseMoveCapture":
+      case "onMouseUp":
+      case "onMouseUpCapture":
+        return !(!props.disabled || !isInteractive(type));
+
+      default:
+        return !1;
+    }
+}
+
+var EventPluginHub = {
+    injection: {
+        injectEventPluginOrder: EventPluginRegistry_1.injectEventPluginOrder,
+        injectEventPluginsByName: EventPluginRegistry_1.injectEventPluginsByName
+    },
+    getListener: function(inst, registrationName) {
+        var listener;
+        if ("number" == typeof inst.tag) {
+            var stateNode = inst.stateNode;
+            if (!stateNode) return null;
+            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(stateNode);
+            if (!props) return null;
+            if (listener = props[registrationName], shouldPreventMouseEvent(registrationName, inst.type, props)) return null;
+        } else {
+            var currentElement = inst._currentElement;
+            if ("string" == typeof currentElement || "number" == typeof currentElement) return null;
+            if (!inst._rootNodeID) return null;
+            var _props = currentElement.props;
+            if (listener = _props[registrationName], shouldPreventMouseEvent(registrationName, currentElement.type, _props)) return null;
+        }
+        return invariant(!listener || "function" == typeof listener, "Expected %s listener to be a function, instead got type %s", registrationName, typeof listener), 
+        listener;
+    },
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        for (var events, plugins = EventPluginRegistry_1.plugins, i = 0; i < plugins.length; i++) {
+            var possiblePlugin = plugins[i];
+            if (possiblePlugin) {
+                var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
+                extractedEvents && (events = accumulateInto_1(events, extractedEvents));
+            }
+        }
+        return events;
+    },
+    enqueueEvents: function(events) {
+        events && (eventQueue = accumulateInto_1(eventQueue, events));
+    },
+    processEventQueue: function(simulated) {
+        var processingEventQueue = eventQueue;
+        eventQueue = null, simulated ? forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseSimulated) : forEachAccumulated_1(processingEventQueue, executeDispatchesAndReleaseTopLevel), 
+        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented."), 
+        ReactErrorUtils_1.rethrowCaughtError();
+    }
+}, EventPluginHub_1 = EventPluginHub, HostComponent = ReactTypeOfWork.HostComponent;
+
+function getParent(inst) {
+    if (void 0 !== inst._hostParent) return inst._hostParent;
+    if ("number" == typeof inst.tag) {
+        do {
+            inst = inst.return;
+        } while (inst && inst.tag !== HostComponent);
+        if (inst) return inst;
+    }
+    return null;
+}
+
+function getLowestCommonAncestor(instA, instB) {
+    for (var depthA = 0, tempA = instA; tempA; tempA = getParent(tempA)) depthA++;
+    for (var depthB = 0, tempB = instB; tempB; tempB = getParent(tempB)) depthB++;
+    for (;depthA - depthB > 0; ) instA = getParent(instA), depthA--;
+    for (;depthB - depthA > 0; ) instB = getParent(instB), depthB--;
+    for (var depth = depthA; depth--; ) {
+        if (instA === instB || instA === instB.alternate) return instA;
+        instA = getParent(instA), instB = getParent(instB);
+    }
+    return null;
+}
+
+function isAncestor(instA, instB) {
+    for (;instB; ) {
+        if (instA === instB || instA === instB.alternate) return !0;
+        instB = getParent(instB);
+    }
+    return !1;
+}
+
+function getParentInstance(inst) {
+    return getParent(inst);
+}
+
+function traverseTwoPhase(inst, fn, arg) {
+    for (var path = []; inst; ) path.push(inst), inst = getParent(inst);
+    var i;
+    for (i = path.length; i-- > 0; ) fn(path[i], "captured", arg);
+    for (i = 0; i < path.length; i++) fn(path[i], "bubbled", arg);
+}
+
+function traverseEnterLeave(from, to, fn, argFrom, argTo) {
+    for (var common = from && to ? getLowestCommonAncestor(from, to) : null, pathFrom = []; from && from !== common; ) pathFrom.push(from), 
+    from = getParent(from);
+    for (var pathTo = []; to && to !== common; ) pathTo.push(to), to = getParent(to);
+    var i;
+    for (i = 0; i < pathFrom.length; i++) fn(pathFrom[i], "bubbled", argFrom);
+    for (i = pathTo.length; i-- > 0; ) fn(pathTo[i], "captured", argTo);
+}
+
+var ReactTreeTraversal = {
+    isAncestor: isAncestor,
+    getLowestCommonAncestor: getLowestCommonAncestor,
+    getParentInstance: getParentInstance,
+    traverseTwoPhase: traverseTwoPhase,
+    traverseEnterLeave: traverseEnterLeave
+}, getListener = EventPluginHub_1.getListener;
+
+function listenerAtPhase(inst, event, propagationPhase) {
+    var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
+    return getListener(inst, registrationName);
+}
+
+function accumulateDirectionalDispatches(inst, phase, event) {
+    var listener = listenerAtPhase(inst, event, phase);
+    listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+    event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
+}
+
+function accumulateTwoPhaseDispatchesSingle(event) {
+    event && event.dispatchConfig.phasedRegistrationNames && ReactTreeTraversal.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
+}
+
+function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
+    if (event && event.dispatchConfig.phasedRegistrationNames) {
+        var targetInst = event._targetInst, parentInst = targetInst ? ReactTreeTraversal.getParentInstance(targetInst) : null;
+        ReactTreeTraversal.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
+    }
+}
+
+function accumulateDispatches(inst, ignoredDirection, event) {
+    if (inst && event && event.dispatchConfig.registrationName) {
+        var registrationName = event.dispatchConfig.registrationName, listener = getListener(inst, registrationName);
+        listener && (event._dispatchListeners = accumulateInto_1(event._dispatchListeners, listener), 
+        event._dispatchInstances = accumulateInto_1(event._dispatchInstances, inst));
+    }
+}
+
+function accumulateDirectDispatchesSingle(event) {
+    event && event.dispatchConfig.registrationName && accumulateDispatches(event._targetInst, null, event);
+}
+
+function accumulateTwoPhaseDispatches(events) {
+    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingle);
+}
+
+function accumulateTwoPhaseDispatchesSkipTarget(events) {
+    forEachAccumulated_1(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
+}
+
+function accumulateEnterLeaveDispatches(leave, enter, from, to) {
+    ReactTreeTraversal.traverseEnterLeave(from, to, accumulateDispatches, leave, enter);
+}
+
+function accumulateDirectDispatches(events) {
+    forEachAccumulated_1(events, accumulateDirectDispatchesSingle);
+}
+
+var EventPropagators = {
+    accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches,
+    accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget,
+    accumulateDirectDispatches: accumulateDirectDispatches,
+    accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches
+}, EventPropagators_1 = EventPropagators, EVENT_POOL_SIZE = 10, shouldBeReleasedProperties = [ "dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances" ], EventInterface = {
+    type: null,
+    target: null,
+    currentTarget: emptyFunction.thatReturnsNull,
+    eventPhase: null,
+    bubbles: null,
+    cancelable: null,
+    timeStamp: function(event) {
+        return event.timeStamp || Date.now();
+    },
+    defaultPrevented: null,
+    isTrusted: null
+};
+
+function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
+    this.dispatchConfig = dispatchConfig, this._targetInst = targetInst, this.nativeEvent = nativeEvent;
+    var Interface = this.constructor.Interface;
+    for (var propName in Interface) if (Interface.hasOwnProperty(propName)) {
+        var normalize = Interface[propName];
+        normalize ? this[propName] = normalize(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName];
+    }
+    var defaultPrevented = null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue;
+    return this.isDefaultPrevented = defaultPrevented ? emptyFunction.thatReturnsTrue : emptyFunction.thatReturnsFalse, 
+    this.isPropagationStopped = emptyFunction.thatReturnsFalse, this;
+}
+
+Object.assign(SyntheticEvent.prototype, {
+    preventDefault: function() {
+        this.defaultPrevented = !0;
+        var event = this.nativeEvent;
+        event && (event.preventDefault ? event.preventDefault() : "unknown" != typeof event.returnValue && (event.returnValue = !1), 
+        this.isDefaultPrevented = emptyFunction.thatReturnsTrue);
+    },
+    stopPropagation: function() {
+        var event = this.nativeEvent;
+        event && (event.stopPropagation ? event.stopPropagation() : "unknown" != typeof event.cancelBubble && (event.cancelBubble = !0), 
+        this.isPropagationStopped = emptyFunction.thatReturnsTrue);
+    },
+    persist: function() {
+        this.isPersistent = emptyFunction.thatReturnsTrue;
+    },
+    isPersistent: emptyFunction.thatReturnsFalse,
+    destructor: function() {
+        var Interface = this.constructor.Interface;
+        for (var propName in Interface) this[propName] = null;
+        for (var i = 0; i < shouldBeReleasedProperties.length; i++) this[shouldBeReleasedProperties[i]] = null;
+    }
+}), SyntheticEvent.Interface = EventInterface, SyntheticEvent.augmentClass = function(Class, Interface) {
+    var Super = this, E = function() {};
+    E.prototype = Super.prototype;
+    var prototype = new E();
+    Object.assign(prototype, Class.prototype), Class.prototype = prototype, Class.prototype.constructor = Class, 
+    Class.Interface = Object.assign({}, Super.Interface, Interface), Class.augmentClass = Super.augmentClass, 
+    addEventPoolingTo(Class);
+}, addEventPoolingTo(SyntheticEvent);
+
+var SyntheticEvent_1 = SyntheticEvent;
+
+function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
+    var EventConstructor = this;
+    if (EventConstructor.eventPool.length) {
+        var instance = EventConstructor.eventPool.pop();
+        return EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst), 
+        instance;
+    }
+    return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
+}
+
+function releasePooledEvent(event) {
+    var EventConstructor = this;
+    invariant(event instanceof EventConstructor, "Trying to release an event instance  into a pool of a different type."), 
+    event.destructor(), EventConstructor.eventPool.length < EVENT_POOL_SIZE && EventConstructor.eventPool.push(event);
+}
+
+function addEventPoolingTo(EventConstructor) {
+    EventConstructor.eventPool = [], EventConstructor.getPooled = getPooledEvent, EventConstructor.release = releasePooledEvent;
+}
+
+var customBubblingEventTypes = UIManager.customBubblingEventTypes, customDirectEventTypes = UIManager.customDirectEventTypes, allTypesByEventName = {};
+
+for (var bubblingTypeName in customBubblingEventTypes) allTypesByEventName[bubblingTypeName] = customBubblingEventTypes[bubblingTypeName];
+
+for (var directTypeName in customDirectEventTypes) warning(!customBubblingEventTypes[directTypeName], "Event cannot be both direct and bubbling: %s", directTypeName), 
+allTypesByEventName[directTypeName] = customDirectEventTypes[directTypeName];
+
+var ReactNativeBridgeEventPlugin = {
+    eventTypes: Object.assign({}, customBubblingEventTypes, customDirectEventTypes),
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType], directDispatchConfig = customDirectEventTypes[topLevelType], event = SyntheticEvent_1.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
+        if (bubbleDispatchConfig) EventPropagators_1.accumulateTwoPhaseDispatches(event); else {
+            if (!directDispatchConfig) return null;
+            EventPropagators_1.accumulateDirectDispatches(event);
+        }
+        return event;
+    }
+}, ReactNativeBridgeEventPlugin_1 = ReactNativeBridgeEventPlugin;
+
+function runEventQueueInBatch(events) {
+    EventPluginHub_1.enqueueEvents(events), EventPluginHub_1.processEventQueue(!1);
+}
+
+var ReactEventEmitterMixin = {
+    handleTopLevel: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        runEventQueueInBatch(EventPluginHub_1.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget));
+    }
+}, ReactEventEmitterMixin_1 = ReactEventEmitterMixin, fiberHostComponent = null, ReactControlledComponentInjection = {
+    injectFiberControlledHostComponent: function(hostComponentImpl) {
+        fiberHostComponent = hostComponentImpl;
+    }
+}, restoreTarget = null, restoreQueue = null;
+
+function restoreStateOfTarget(target) {
+    var internalInstance = EventPluginUtils_1.getInstanceFromNode(target);
+    if (internalInstance) {
+        if ("number" == typeof internalInstance.tag) {
+            invariant(fiberHostComponent && "function" == typeof fiberHostComponent.restoreControlledState, "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.");
+            var props = EventPluginUtils_1.getFiberCurrentPropsFromNode(internalInstance.stateNode);
+            return void fiberHostComponent.restoreControlledState(internalInstance.stateNode, internalInstance.type, props);
+        }
+        invariant("function" == typeof internalInstance.restoreControlledState, "The internal instance must be a React host component. " + "This error is likely caused by a bug in React. Please file an issue."), 
+        internalInstance.restoreControlledState();
+    }
+}
+
+var ReactControlledComponent = {
+    injection: ReactControlledComponentInjection,
+    enqueueStateRestore: function(target) {
+        restoreTarget ? restoreQueue ? restoreQueue.push(target) : restoreQueue = [ target ] : restoreTarget = target;
+    },
+    restoreStateIfNeeded: function() {
+        if (restoreTarget) {
+            var target = restoreTarget, queuedTargets = restoreQueue;
+            if (restoreTarget = null, restoreQueue = null, restoreStateOfTarget(target), queuedTargets) for (var i = 0; i < queuedTargets.length; i++) restoreStateOfTarget(queuedTargets[i]);
+        }
+    }
+}, ReactControlledComponent_1 = ReactControlledComponent, stackBatchedUpdates = function(fn, a, b, c, d, e) {
+    return fn(a, b, c, d, e);
+}, fiberBatchedUpdates = function(fn, bookkeeping) {
+    return fn(bookkeeping);
+};
+
+function performFiberBatchedUpdates(fn, bookkeeping) {
+    return fiberBatchedUpdates(fn, bookkeeping);
+}
+
+function batchedUpdates$1(fn, bookkeeping) {
+    return stackBatchedUpdates(performFiberBatchedUpdates, fn, bookkeeping);
+}
+
+var isNestingBatched = !1;
+
+function batchedUpdatesWithControlledComponents(fn, bookkeeping) {
+    if (isNestingBatched) return batchedUpdates$1(fn, bookkeeping);
+    isNestingBatched = !0;
+    try {
+        return batchedUpdates$1(fn, bookkeeping);
+    } finally {
+        isNestingBatched = !1, ReactControlledComponent_1.restoreStateIfNeeded();
+    }
+}
+
+var ReactGenericBatchingInjection = {
+    injectStackBatchedUpdates: function(_batchedUpdates) {
+        stackBatchedUpdates = _batchedUpdates;
+    },
+    injectFiberBatchedUpdates: function(_batchedUpdates) {
+        fiberBatchedUpdates = _batchedUpdates;
+    }
+}, ReactGenericBatching = {
+    batchedUpdates: batchedUpdatesWithControlledComponents,
+    injection: ReactGenericBatchingInjection
+}, ReactGenericBatching_1 = ReactGenericBatching, EMPTY_NATIVE_EVENT = {}, touchSubsequence = function(touches, indices) {
+    for (var ret = [], i = 0; i < indices.length; i++) ret.push(touches[indices[i]]);
+    return ret;
+}, removeTouchesAtIndices = function(touches, indices) {
+    for (var rippedOut = [], temp = touches, i = 0; i < indices.length; i++) {
+        var index = indices[i];
+        rippedOut.push(touches[index]), temp[index] = null;
+    }
+    for (var fillAt = 0, j = 0; j < temp.length; j++) {
+        var cur = temp[j];
+        null !== cur && (temp[fillAt++] = cur);
+    }
+    return temp.length = fillAt, rippedOut;
+}, ReactNativeEventEmitter = Object.assign({}, ReactEventEmitterMixin_1, {
+    registrationNames: EventPluginRegistry_1.registrationNameModules,
+    getListener: EventPluginHub_1.getListener,
+    _receiveRootNodeIDEvent: function(rootNodeID, topLevelType, nativeEventParam) {
+        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT, inst = ReactNativeComponentTree_1.getInstanceFromNode(rootNodeID);
+        ReactGenericBatching_1.batchedUpdates(function() {
+            ReactNativeEventEmitter.handleTopLevel(topLevelType, inst, nativeEvent, nativeEvent.target);
+        });
+    },
+    receiveEvent: function(tag, topLevelType, nativeEventParam) {
+        var rootNodeID = tag;
+        ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
+    },
+    receiveTouches: function(eventTopLevelType, touches, changedIndices) {
+        for (var changedTouches = "topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices), jj = 0; jj < changedTouches.length; jj++) {
+            var touch = changedTouches[jj];
+            touch.changedTouches = changedTouches, touch.touches = touches;
+            var nativeEvent = touch, rootNodeID = null, target = nativeEvent.target;
+            null !== target && void 0 !== target && (target < ReactNativeTagHandles_1.tagsStartAt || (rootNodeID = target)), 
+            ReactNativeEventEmitter._receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
+        }
+    }
+}), ReactNativeEventEmitter_1 = ReactNativeEventEmitter, ReactNativeEventPluginOrder = [ "ResponderEventPlugin", "ReactNativeBridgeEventPlugin" ], ReactNativeEventPluginOrder_1 = ReactNativeEventPluginOrder, ReactNativeGlobalResponderHandler = {
+    onChange: function(from, to, blockNativeResponder) {
+        if (null !== to) {
+            var tag = "number" != typeof to.tag ? to._rootNodeID : to.stateNode._nativeTag;
+            UIManager.setJSResponder(tag, blockNativeResponder);
+        } else UIManager.clearJSResponder();
+    }
+}, ReactNativeGlobalResponderHandler_1 = ReactNativeGlobalResponderHandler, ResponderEventInterface = {
+    touchHistory: function(nativeEvent) {
+        return null;
+    }
+};
+
+function ResponderSyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
+    return SyntheticEvent_1.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
+}
+
+SyntheticEvent_1.augmentClass(ResponderSyntheticEvent, ResponderEventInterface);
+
+var ResponderSyntheticEvent_1 = ResponderSyntheticEvent, isEndish$2 = EventPluginUtils_1.isEndish, isMoveish$2 = EventPluginUtils_1.isMoveish, isStartish$2 = EventPluginUtils_1.isStartish, warning$7, MAX_TOUCH_BANK = 20, touchBank = [], touchHistory = {
+    touchBank: touchBank,
+    numberActiveTouches: 0,
+    indexOfSingleActiveTouch: -1,
+    mostRecentTimeStamp: 0
+};
+
+function timestampForTouch(touch) {
+    return touch.timeStamp || touch.timestamp;
+}
+
+function createTouchRecord(touch) {
+    return {
+        touchActive: !0,
+        startPageX: touch.pageX,
+        startPageY: touch.pageY,
+        startTimeStamp: timestampForTouch(touch),
+        currentPageX: touch.pageX,
+        currentPageY: touch.pageY,
+        currentTimeStamp: timestampForTouch(touch),
+        previousPageX: touch.pageX,
+        previousPageY: touch.pageY,
+        previousTimeStamp: timestampForTouch(touch)
+    };
+}
+
+function resetTouchRecord(touchRecord, touch) {
+    touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, 
+    touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, 
+    touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), 
+    touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, 
+    touchRecord.previousTimeStamp = timestampForTouch(touch);
+}
+
+function getTouchIdentifier(_ref) {
+    var identifier = _ref.identifier;
+    return invariant(null != identifier, "Touch object is missing identifier."), warning$7(identifier <= MAX_TOUCH_BANK, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK), 
+    identifier;
+}
+
+function recordTouchStart(touch) {
+    var identifier = getTouchIdentifier(touch), touchRecord = touchBank[identifier];
+    touchRecord ? resetTouchRecord(touchRecord, touch) : touchBank[identifier] = createTouchRecord(touch), 
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+}
+
+function recordTouchMove(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, 
+    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+}
+
+function recordTouchEnd(touch) {
+    var touchRecord = touchBank[getTouchIdentifier(touch)];
+    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, 
+    touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, 
+    touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, 
+    touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.error("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
+}
+
+function printTouch(touch) {
+    return JSON.stringify({
+        identifier: touch.identifier,
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        timestamp: timestampForTouch(touch)
+    });
+}
+
+function printTouchBank() {
+    var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+    return touchBank.length > MAX_TOUCH_BANK && (printed += " (original size: " + touchBank.length + ")"), 
+    printed;
+}
+
+var ResponderTouchHistoryStore = {
+    recordTouchTrack: function(topLevelType, nativeEvent) {
+        if (isMoveish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove); else if (isStartish$2(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), 
+        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier); else if (isEndish$2(topLevelType) && (nativeEvent.changedTouches.forEach(recordTouchEnd), 
+        touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches)) for (var i = 0; i < touchBank.length; i++) {
+            var touchTrackToCheck = touchBank[i];
+            if (null != touchTrackToCheck && touchTrackToCheck.touchActive) {
+                touchHistory.indexOfSingleActiveTouch = i;
+                break;
+            }
+        }
+    },
+    touchHistory: touchHistory
+}, ResponderTouchHistoryStore_1 = ResponderTouchHistoryStore;
+
+function accumulate(current, next) {
+    return invariant(null != next, "accumulate(...): Accumulated items must be not be null or undefined."), 
+    null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [ current ].concat(next) : [ current, next ];
+}
+
+var accumulate_1 = accumulate, isStartish$1 = EventPluginUtils_1.isStartish, isMoveish$1 = EventPluginUtils_1.isMoveish, isEndish$1 = EventPluginUtils_1.isEndish, executeDirectDispatch$1 = EventPluginUtils_1.executeDirectDispatch, hasDispatches$1 = EventPluginUtils_1.hasDispatches, executeDispatchesInOrderStopAtTrue$1 = EventPluginUtils_1.executeDispatchesInOrderStopAtTrue, responderInst = null, trackedTouchCount = 0, previousActiveTouches = 0, changeResponder = function(nextResponderInst, blockHostResponder) {
+    var oldResponderInst = responderInst;
+    responderInst = nextResponderInst, null !== ResponderEventPlugin.GlobalResponderHandler && ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
+}, eventTypes = {
+    startShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onStartShouldSetResponder",
+            captured: "onStartShouldSetResponderCapture"
+        }
+    },
+    scrollShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onScrollShouldSetResponder",
+            captured: "onScrollShouldSetResponderCapture"
+        }
+    },
+    selectionChangeShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onSelectionChangeShouldSetResponder",
+            captured: "onSelectionChangeShouldSetResponderCapture"
+        }
+    },
+    moveShouldSetResponder: {
+        phasedRegistrationNames: {
+            bubbled: "onMoveShouldSetResponder",
+            captured: "onMoveShouldSetResponderCapture"
+        }
+    },
+    responderStart: {
+        registrationName: "onResponderStart"
+    },
+    responderMove: {
+        registrationName: "onResponderMove"
+    },
+    responderEnd: {
+        registrationName: "onResponderEnd"
+    },
+    responderRelease: {
+        registrationName: "onResponderRelease"
+    },
+    responderTerminationRequest: {
+        registrationName: "onResponderTerminationRequest"
+    },
+    responderGrant: {
+        registrationName: "onResponderGrant"
+    },
+    responderReject: {
+        registrationName: "onResponderReject"
+    },
+    responderTerminate: {
+        registrationName: "onResponderTerminate"
+    }
+};
+
+function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+    var shouldSetEventType = isStartish$1(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish$1(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder, bubbleShouldSetFrom = responderInst ? ReactTreeTraversal.getLowestCommonAncestor(responderInst, targetInst) : targetInst, skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst, shouldSetEvent = ResponderSyntheticEvent_1.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
+    shouldSetEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, skipOverBubbleShouldSetFrom ? EventPropagators_1.accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent) : EventPropagators_1.accumulateTwoPhaseDispatches(shouldSetEvent);
+    var wantsResponderInst = executeDispatchesInOrderStopAtTrue$1(shouldSetEvent);
+    if (shouldSetEvent.isPersistent() || shouldSetEvent.constructor.release(shouldSetEvent), 
+    !wantsResponderInst || wantsResponderInst === responderInst) return null;
+    var extracted, grantEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
+    grantEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(grantEvent);
+    var blockHostResponder = !0 === executeDirectDispatch$1(grantEvent);
+    if (responderInst) {
+        var terminationRequestEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
+        terminationRequestEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, 
+        EventPropagators_1.accumulateDirectDispatches(terminationRequestEvent);
+        var shouldSwitch = !hasDispatches$1(terminationRequestEvent) || executeDirectDispatch$1(terminationRequestEvent);
+        if (terminationRequestEvent.isPersistent() || terminationRequestEvent.constructor.release(terminationRequestEvent), 
+        shouldSwitch) {
+            var terminateEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
+            terminateEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(terminateEvent), 
+            extracted = accumulate_1(extracted, [ grantEvent, terminateEvent ]), changeResponder(wantsResponderInst, blockHostResponder);
+        } else {
+            var rejectEvent = ResponderSyntheticEvent_1.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
+            rejectEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(rejectEvent), 
+            extracted = accumulate_1(extracted, rejectEvent);
+        }
+    } else extracted = accumulate_1(extracted, grantEvent), changeResponder(wantsResponderInst, blockHostResponder);
+    return extracted;
+}
+
+function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
+    return topLevelInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && "topSelectionChange" === topLevelType || isStartish$1(topLevelType) || isMoveish$1(topLevelType));
+}
+
+function noResponderTouches(nativeEvent) {
+    var touches = nativeEvent.touches;
+    if (!touches || 0 === touches.length) return !0;
+    for (var i = 0; i < touches.length; i++) {
+        var activeTouch = touches[i], target = activeTouch.target;
+        if (null !== target && void 0 !== target && 0 !== target) {
+            var targetInst = EventPluginUtils_1.getInstanceFromNode(target);
+            if (ReactTreeTraversal.isAncestor(responderInst, targetInst)) return !1;
+        }
+    }
+    return !0;
+}
+
+var ResponderEventPlugin = {
+    _getResponder: function() {
+        return responderInst;
+    },
+    eventTypes: eventTypes,
+    extractEvents: function(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
+        if (isStartish$1(topLevelType)) trackedTouchCount += 1; else if (isEndish$1(topLevelType)) {
+            if (!(trackedTouchCount >= 0)) return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), 
+            null;
+            trackedTouchCount -= 1;
+        }
+        ResponderTouchHistoryStore_1.recordTouchTrack(topLevelType, nativeEvent);
+        var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null, isResponderTouchStart = responderInst && isStartish$1(topLevelType), isResponderTouchMove = responderInst && isMoveish$1(topLevelType), isResponderTouchEnd = responderInst && isEndish$1(topLevelType), incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;
+        if (incrementalTouch) {
+            var gesture = ResponderSyntheticEvent_1.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
+            gesture.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(gesture), 
+            extracted = accumulate_1(extracted, gesture);
+        }
+        var isResponderTerminate = responderInst && "topTouchCancel" === topLevelType, isResponderRelease = responderInst && !isResponderTerminate && isEndish$1(topLevelType) && noResponderTouches(nativeEvent), finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;
+        if (finalTouch) {
+            var finalEvent = ResponderSyntheticEvent_1.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
+            finalEvent.touchHistory = ResponderTouchHistoryStore_1.touchHistory, EventPropagators_1.accumulateDirectDispatches(finalEvent), 
+            extracted = accumulate_1(extracted, finalEvent), changeResponder(null);
+        }
+        var numberActiveTouches = ResponderTouchHistoryStore_1.touchHistory.numberActiveTouches;
+        return ResponderEventPlugin.GlobalInteractionHandler && numberActiveTouches !== previousActiveTouches && ResponderEventPlugin.GlobalInteractionHandler.onChange(numberActiveTouches), 
+        previousActiveTouches = numberActiveTouches, extracted;
+    },
+    GlobalResponderHandler: null,
+    GlobalInteractionHandler: null,
+    injection: {
+        injectGlobalResponderHandler: function(GlobalResponderHandler) {
+            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
+        },
+        injectGlobalInteractionHandler: function(GlobalInteractionHandler) {
+            ResponderEventPlugin.GlobalInteractionHandler = GlobalInteractionHandler;
+        }
+    }
+}, ResponderEventPlugin_1 = ResponderEventPlugin;
+
+RCTEventEmitter.register(ReactNativeEventEmitter_1), EventPluginHub_1.injection.injectEventPluginOrder(ReactNativeEventPluginOrder_1), 
+EventPluginUtils_1.injection.injectComponentTree(ReactNativeComponentTree_1), ResponderEventPlugin_1.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler_1), 
+EventPluginHub_1.injection.injectEventPluginsByName({
+    ResponderEventPlugin: ResponderEventPlugin_1,
+    ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin_1
+});
+
+var RESET_BATCHED_UPDATES = {
     initialize: emptyFunction,
     close: function() {
         ReactDefaultBatchingStrategy.isBatchingUpdates = !1;
@@ -1837,42 +1872,27 @@ Object.assign(ReactSimpleEmptyComponent.prototype, {
 
 var ReactSimpleEmptyComponent_1 = ReactSimpleEmptyComponent;
 
-function inject$1() {
-    ReactGenericBatching_1.injection.injectStackBatchedUpdates(ReactUpdates_1.batchedUpdates), 
-    ReactUpdates_1.injection.injectReconcileTransaction(ReactNativeComponentEnvironment_1.ReactReconcileTransaction), 
-    ReactUpdates_1.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy_1), 
-    ReactComponentEnvironment_1.injection.injectEnvironment(ReactNativeComponentEnvironment_1);
-    var EmptyComponent = function(instantiate) {
-        var View = require("View");
-        return new ReactSimpleEmptyComponent_1(React.createElement(View, {
-            collapsable: !0,
-            style: {
-                position: "absolute"
-            }
-        }), instantiate);
-    };
-    ReactEmptyComponent_1.injection.injectEmptyComponentFactory(EmptyComponent), ReactHostComponent_1.injection.injectTextComponentClass(ReactNativeTextComponent_1), 
-    ReactHostComponent_1.injection.injectGenericComponentClass(function(tag) {
-        var info = "";
-        "string" == typeof tag && /^[a-z]/.test(tag) && (info += " Each component name should start with an uppercase letter."), 
-        invariant(!1, "Expected a component class, got %s.%s", tag, info);
-    });
-}
+ReactGenericBatching_1.injection.injectStackBatchedUpdates(ReactUpdates_1.batchedUpdates), 
+ReactUpdates_1.injection.injectReconcileTransaction(ReactNativeComponentEnvironment_1.ReactReconcileTransaction), 
+ReactUpdates_1.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy_1), 
+ReactComponentEnvironment_1.injection.injectEnvironment(ReactNativeComponentEnvironment_1);
 
-var ReactNativeStackInjection = {
-    inject: inject$1
-}, getInspectorDataForViewTag = void 0;
-
-getInspectorDataForViewTag = function() {
-    invariant(!1, "getInspectorDataForViewTag() is not available in production");
+var EmptyComponent = function(instantiate) {
+    var View = require("View");
+    return new ReactSimpleEmptyComponent_1(React.createElement(View, {
+        collapsable: !0,
+        style: {
+            position: "absolute"
+        }
+    }), instantiate);
 };
 
-var ReactNativeStackInspector = {
-    getInspectorDataForViewTag: getInspectorDataForViewTag
-}, findNumericNodeHandleStack = function(componentOrHandle) {
-    var nodeHandle = findNodeHandle_1(componentOrHandle);
-    return null == nodeHandle || "number" == typeof nodeHandle ? nodeHandle : nodeHandle.getHostNode();
-};
+ReactEmptyComponent_1.injection.injectEmptyComponentFactory(EmptyComponent), ReactHostComponent_1.injection.injectTextComponentClass(ReactNativeTextComponent_1), 
+ReactHostComponent_1.injection.injectGenericComponentClass(function(tag) {
+    var info = "";
+    "string" == typeof tag && /^[a-z]/.test(tag) && (info += " Each component name should start with an uppercase letter."), 
+    invariant(!1, "Expected a component class, got %s.%s", tag, info);
+});
 
 function _classCallCheck$2(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
@@ -2465,11 +2485,7 @@ function takeSnapshot(view, options) {
     UIManager.__takeSnapshot(view, options);
 }
 
-var takeSnapshot_1 = takeSnapshot;
-
-ReactNativeInjection.inject(), ReactNativeStackInjection.inject();
-
-var render = function(element, mountInto, callback) {
+var takeSnapshot_1 = takeSnapshot, render = function(element, mountInto, callback) {
     return ReactNativeMount_1.renderComponent(element, mountInto, callback);
 }, ReactNativeStack = {
     NativeComponent: ReactNativeComponent_1,
diff --git a/jest/setup.js b/jest/setup.js
index 4a94e5e4414..8a9251ec6d6 100644
--- a/jest/setup.js
+++ b/jest/setup.js
@@ -68,6 +68,44 @@ jest
     };
     return DataSource;
   })
+  .mock('AnimatedImplementation', () => {
+    const AnimatedImplementation = require.requireActual('AnimatedImplementation');
+    const oldCreate = AnimatedImplementation.createAnimatedComponent;
+    AnimatedImplementation.createAnimatedComponent = function(Component) {
+      const Wrapped = oldCreate(Component);
+      Wrapped.__skipSetNativeProps_FOR_TESTS_ONLY = true;
+      return Wrapped;
+    };
+    return AnimatedImplementation;
+  })
+  .mock('ReactNative', () => {
+    const ReactNative = require.requireActual('ReactNative');
+    const NativeMethodsMixin =
+      ReactNative.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.NativeMethodsMixin;
+    [
+      'measure',
+      'measureInWindow',
+      'measureLayout',
+      'setNativeProps',
+      'focus',
+      'blur',
+    ].forEach((key) => {
+      let warned = false;
+      NativeMethodsMixin[key] = function() {
+        if (warned) {
+          return;
+        }
+        warned = true;
+        console.warn(
+          'Calling .' + key + '() in the test renderer environment is not ' +
+            'supported. Instead, mock out your components that use ' +
+            'findNodeHandle with replacements that don\'t rely on the ' +
+            'native environment.',
+        );
+      };
+    });
+    return ReactNative;
+  })
   .mock('ensureComponentIsNative', () => () => true);
 
 const mockEmptyObject = {};
diff --git a/package.json b/package.json
index e18a9c5db76..fd131e13377 100644
--- a/package.json
+++ b/package.json
@@ -133,7 +133,7 @@
     "react-native": "local-cli/wrong-react-native.js"
   },
   "peerDependencies": {
-    "react": "16.0.0-alpha.12"
+    "react": "16.0.0-beta.5"
   },
   "dependencies": {
     "absolute-path": "^0.0.0",
@@ -155,7 +155,7 @@
     "denodeify": "^1.2.1",
     "envinfo": "^3.0.0",
     "event-target-shim": "^1.0.5",
-    "fbjs": "0.8.12",
+    "fbjs": "0.8.14",
     "fbjs-scripts": "^0.8.1",
     "fs-extra": "^1.0.0",
     "glob": "^7.1.1",
@@ -202,8 +202,8 @@
     "jest": "20.1.0-delta.4",
     "mock-fs": "^4.4.1",
     "prettier": "1.5.2",
-    "react": "16.0.0-alpha.12",
-    "react-test-renderer": "16.0.0-alpha.12",
+    "react": "16.0.0-beta.5",
+    "react-test-renderer": "16.0.0-beta.5",
     "shelljs": "0.6.0",
     "sinon": "^2.2.0"
   }