From 70913a4623c53db8a0db578eec30cad8671f8319 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?H=C3=A9ctor=20Ramos?= <hramos@fb.com>
Date: Tue, 24 Jul 2018 14:45:35 -0700
Subject: [PATCH] React sync for revisions ae14317...ca0941f
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Summary:
@public
This sync includes the following changes:
- **[ca0941fce](https://github.com/facebook/react/commit/ca0941fce)**: Add regression test for Placeholder fallbacks with lifecycle methods (#13254) //<Andrew Clark>//
- **[a32c727f2](https://github.com/facebook/react/commit/a32c727f2)**: Optimize readContext for Subsequent Reads of All Bits (#13248) //<Sebastian Markbåge>//
- **[2b509e2c8](https://github.com/facebook/react/commit/2b509e2c8)**: [Experimental] API for reading context from within any render phase function (#13139) //<Andrew Clark>//
- **[5776fa3fc](https://github.com/facebook/react/commit/5776fa3fc)**: Update www warning shim (#13244) //<Dan Abramov>//
- **[3d3506d37](https://github.com/facebook/react/commit/3d3506d37)**: Include Modes in the component stack (#13240) //<Dan Abramov>//
- **[71b4e9990](https://github.com/facebook/react/commit/71b4e9990)**: [react-test-renderer] Jest matchers for async tests (#13236) //<Andrew Clark>//
- **[2c560cb99](https://github.com/facebook/react/commit/2c560cb99)**: Fix unwinding starting with a wrong Fiber on error in the complete phase (#13237) //<Dan Abramov>//
- **[ead08827d](https://github.com/facebook/react/commit/ead08827d)**: Add more flexibility in testing errors in begin/complete phases (#13235) //<Dan Abramov>//
- **[e4e58343e](https://github.com/facebook/react/commit/e4e58343e)**: Move unstable_yield to main export (#13232) //<Andrew Clark>//
- **[0e235bb8f](https://github.com/facebook/react/commit/0e235bb8f)**: Removed unused state argument in unsubscribe method of <Subscription /> (#13233) //<Mateusz Burzyński>//
- **[236f60872](https://github.com/facebook/react/commit/236f60872)**: Fail tests if toWarnDev() does not wrap warnings in array (#13227) //<Dan Abramov>//
- **[acbb4f93f](https://github.com/facebook/react/commit/acbb4f93f)**: Remove the use of proxies for synthetic events in DEV (#13225) //<Dan Abramov>//
- **[171e0b7d4](https://github.com/facebook/react/commit/171e0b7d4)**: Fix “no onChange handler” warning to fire on falsy values ("", 0, false) too (#12628) //<Nicole Levy>//
- **[606c30aa5](https://github.com/facebook/react/commit/606c30aa5)**: fixed a typo in commentout in ReactFiberUnwindWork.js (#13172) //<Fumiya Shibusawa>//
- **[9f78913b2](https://github.com/facebook/react/commit/9f78913b2)**: Update prettier (#13205) //<Johan Henriksson>//
- **[6d3e26288](https://github.com/facebook/react/commit/6d3e26288)**: Remove unnecessary `typeof` checks (#13196) //<jddxf>//
- **[82c7ca4cc](https://github.com/facebook/react/commit/82c7ca4cc)**: Add component stacks to some warnings (#13218) //<Dan Abramov>//
- **[21ac62c77](https://github.com/facebook/react/commit/21ac62c77)**: Fix a portal unmounting crash for renderers with distinct Instance and Container (#13220) //<Thibault Malbranche>//
- **[d6a0626b3](https://github.com/facebook/react/commit/d6a0626b3)**: Set current fiber during before-mutation traversal (#13219) //<Dan Abramov>//
- **[f9358c51c](https://github.com/facebook/react/commit/f9358c51c)**: Change warning() to automatically inject the stack, and add warningWithoutStack() as opt-out (#13161) //<Dan Abramov>//
- **[467d13910](https://github.com/facebook/react/commit/467d13910)**: Enforce presence or absence of component stack in tests (#13215) //<Dan Abramov>//
- **[43ffae2d1](https://github.com/facebook/react/commit/43ffae2d1)**: Suspending inside a constructor outside of strict mode (#13200) //<Andrew Clark>//
- **[659a29cec](https://github.com/facebook/react/commit/659a29cec)**: Reorganize how shared internals are accessed (#13201) //<Dan Abramov>//
- **[58f3b29d9](https://github.com/facebook/react/commit/58f3b29d9)**: Added SSR/hydration tests for modes, forwardRef, and Profiler (#13195) //<Brian Vaughn>//
- **[1c89cb62f](https://github.com/facebook/react/commit/1c89cb62f)**: Use ReactDebugCurrentFrame.getStackAddendum() in element validator (#13198) //<Dan Abramov>//
- **[e6076ecf4](https://github.com/facebook/react/commit/e6076ecf4)**: Remove ad-hoc forks of getComponentName() and fix it (#13197) //<Dan Abramov>//
- **[32f6f258b](https://github.com/facebook/react/commit/32f6f258b)**: Remove event simulation of onChange events (#13176) //<Philipp Spieß>//
- **[9ca37f843](https://github.com/facebook/react/commit/9ca37f843)**: docs: update comments (#13043) //<Sen Yang>//
- **[f89f25f47](https://github.com/facebook/react/commit/f89f25f47)**: Correct type of `ref` in forwardRef render() (#13100) //<Moti Zilberman>//
- **[7b99ceabe](https://github.com/facebook/react/commit/7b99ceabe)**: Deprecate test utils mock component follow up (#13194) //<Brian Vaughn>//
- **[6ebc8f3c0](https://github.com/facebook/react/commit/6ebc8f3c0)**: Add support for re-entrant SSR stacks (#13181) //<Dan Abramov>//
- **[d64d1ddb5](https://github.com/facebook/react/commit/d64d1ddb5)**: Deprecate ReactTestUtils.mockComponent() (#13193) //<Brian Vaughn>//
- **[e79366d54](https://github.com/facebook/react/commit/e79366d54)**: Link create-subscription doc to GH issue with de-opt explanation (#13187) //<Brian Vaughn>//
- **[1f32d3c6d](https://github.com/facebook/react/commit/1f32d3c6d)**: Test renderer flushAll method verifies an array of expected yields (#13174) //<Brian Vaughn>//
- **[377e1a049](https://github.com/facebook/react/commit/377e1a049)**: Add a test for SSR stack traces (#13180) //<Dan Abramov>//
- **[96d38d178](https://github.com/facebook/react/commit/96d38d178)**: Fix concatenation of null to a warning message (#13166) //<Dan Abramov>//
- **[095dd5049](https://github.com/facebook/react/commit/095dd5049)**: Add DEV warning if forwardRef function doesn't use the ref param (#13168) //<Brian Vaughn>//
- **[566259567](https://github.com/facebook/react/commit/566259567)**: Refactor stack handling (no functional changes) (#13165) //<Dan Abramov>//
- **[ebbd22143](https://github.com/facebook/react/commit/ebbd22143)**: Configure react-test-renderer as a secondary (#13164) //<Brandon Dail>//
- **[ddc91af79](https://github.com/facebook/react/commit/ddc91af79)**: Decrease nested update limit from 1000 to 50 (#13163) //<Andrew Clark>//
- **[3596e40b3](https://github.com/facebook/react/commit/3596e40b3)**: Fix nested update bug (#13160) //<Andrew Clark>//
- **[449f6ddd5](https://github.com/facebook/react/commit/449f6ddd5)**: create a new FeatureFlags file for test renderer on www (#13159) //<Chang Yan>//
- **[f762b3abb](https://github.com/facebook/react/commit/f762b3abb)**: Run react-dom SSR import test in jsdom-less environment (#13157) //<Dan Abramov>//
- **[6f6b560a6](https://github.com/facebook/react/commit/6f6b560a6)**: Renamed selfBaseTime/treeBaseTime Fiber attributes to selfBaseDuration/treeBaseDuration (#13156) //<Brian Vaughn>//
- **[1386ccddd](https://github.com/facebook/react/commit/1386ccddd)**: Fix ReferenceError when requestAnimationFrame isn't defined (#13152) //<Dan Abramov>//
- **[f5779bbc1](https://github.com/facebook/react/commit/f5779bbc1)**: Run server rendering test on bundles (#13153) //<Dan Abramov>//
- **[9faf389e7](https://github.com/facebook/react/commit/9faf389e7)**: Reset profiler timer correctly after errors (#13123) //<Brian Vaughn>//
- **[85fe4ddce](https://github.com/facebook/react/commit/85fe4ddce)**: Fix - issue #12765 / the checked attribute is not initially set on the input (#13114) //<XuMM_12>//
- **[07fefe333](https://github.com/facebook/react/commit/07fefe333)**: Drop handling for ms and O prefixes for CSS transition and animation events. (#13133) //<Rouven Weßling>//
- **[88d7ed8bf](https://github.com/facebook/react/commit/88d7ed8bf)**: React.Timeout -> React.Placeholder (#13105) //<Andrew Clark>//
- **[f128fdea4](https://github.com/facebook/react/commit/f128fdea4)**: Suspending outside of strict trees and async trees (#13098) //<Andrew Clark>//
- **[aa8266c4f](https://github.com/facebook/react/commit/aa8266c4f)**: Prepare placeholders before timing out (#13092) //<Andrew Clark>//
- **[c039c16f2](https://github.com/facebook/react/commit/c039c16f2)**: Fix this in a functional component for ShallowRenderer (#13144) //<Toru Kobayashi>//
- **[64e1921aa](https://github.com/facebook/react/commit/64e1921aa)**: Fix Flow type that event target can be null (#13124) //<Sebastian Markbåge>//
- **[6d6de6011](https://github.com/facebook/react/commit/6d6de6011)**: Add PROFILE bundles for www+DOM and fbsource+RN/RF (#13112) //<Brian Vaughn>//
- **[71a60ddb1](https://github.com/facebook/react/commit/71a60ddb1)**: Add link to another article about React renderers //<Dan Abramov>//
- **[6a530e3ba](https://github.com/facebook/react/commit/6a530e3ba)**: adding check for mousemove (#13090) //<Jason Williams>//
- **[c35a1e748](https://github.com/facebook/react/commit/c35a1e748)**: Fix crash during server render in react 16.4.1. (#13088) //<Dustin Masters>//
- **[076bbeace](https://github.com/facebook/react/commit/076bbeace)**: Fall back to 'setTimeout' when 'requestAnimationFrame' is not called (#13091) //<Flarnie Marchan>//
- **[da5c87bdf](https://github.com/facebook/react/commit/da5c87bdf)**: Fixes children when using dangerouslySetInnerHtml in a selected <option> (#13078) //<Michael Ridgway>//
- **[a960d18bc](https://github.com/facebook/react/commit/a960d18bc)**: eliminate unnecessary do-while loop in renderRoot() (#13087) //<Nathan Quarles>//
- **[5b3d17a5f](https://github.com/facebook/react/commit/5b3d17a5f)**: setting a flag, so that the first movement will have the correct value (#13082) //<Jason Williams>//
- **[b0f60895f](https://github.com/facebook/react/commit/b0f60895f)**: Automatically Profile roots when DevTools is present (#13058) //<Brian Vaughn>//
- **[ae8c6dd53](https://github.com/facebook/react/commit/ae8c6dd53)**: remove some redundant lines (#13077) //<Nathan Quarles>//
- **[0fcf92d06](https://github.com/facebook/react/commit/0fcf92d06)**: Add a link to custom renderer intro article //<Dan Abramov>//
- **[97af3e1f3](https://github.com/facebook/react/commit/97af3e1f3)**:  Do not add additional work to a batch that is already rendering (#13072) //<Andrew Clark>//
- **[4fe6eec15](https://github.com/facebook/react/commit/4fe6eec15)**: Always batch updates of like priority within the same event (#13071) //<Andrew Clark>//
- **[8e87c139b](https://github.com/facebook/react/commit/8e87c139b)**: Remove transitive dependency on fbjs (#13075) //<Dan Abramov>//
- **[aeda7b745](https://github.com/facebook/react/commit/aeda7b745)**: Remove fbjs dependency (#13069) //<Dan Abramov>//
- **[b1b3acbd6](https://github.com/facebook/react/commit/b1b3acbd6)**: Inline fbjs/lib/emptyObject (#13055) //<Dan Abramov>//

Release Notes:
[GENERAL] [FEATURE] [React] - React sync for revisions ae14317...ca0941f

Reviewed By: bvaughn

Differential Revision: D8979192

fbshipit-source-id: 7a14d3b0a253a81d162d7f8c899e99cf6ac4fee4
---
 Libraries/Renderer/REVISION                   |    2 +-
 Libraries/Renderer/oss/ReactFabric-dev.js     | 3675 +++++++++-------
 Libraries/Renderer/oss/ReactFabric-prod.js    | 2614 ++++++------
 .../Renderer/oss/ReactFabric-profiling.js     | 2695 ++++++------
 .../Renderer/oss/ReactNativeRenderer-dev.js   | 3687 ++++++++++-------
 .../Renderer/oss/ReactNativeRenderer-prod.js  | 2733 ++++++------
 .../oss/ReactNativeRenderer-profiling.js      | 2820 +++++++------
 Libraries/Renderer/shims/ReactTypes.js        |    1 +
 8 files changed, 10224 insertions(+), 8003 deletions(-)

diff --git a/Libraries/Renderer/REVISION b/Libraries/Renderer/REVISION
index 7e020bc80..fd03ac6ee 100644
--- a/Libraries/Renderer/REVISION
+++ b/Libraries/Renderer/REVISION
@@ -1 +1 @@
-ae14317d6810d5b07d01308a2116a707e5e09983
\ No newline at end of file
+ca0941fce3a03592530f6111f77cbc9c0daf79af
\ No newline at end of file
diff --git a/Libraries/Renderer/oss/ReactFabric-dev.js b/Libraries/Renderer/oss/ReactFabric-dev.js
index c81fac181..bb66ba4e0 100644
--- a/Libraries/Renderer/oss/ReactFabric-dev.js
+++ b/Libraries/Renderer/oss/ReactFabric-dev.js
@@ -17,12 +17,9 @@ if (__DEV__) {
 "use strict";
 
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant");
-var warning = require("fbjs/lib/warning");
 var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry");
 var UIManager = require("UIManager");
 var React = require("react");
-var emptyObject = require("fbjs/lib/emptyObject");
 var deepDiffer = require("deepDiffer");
 var flattenStyle = require("flattenStyle");
 var deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev");
@@ -31,6 +28,53 @@ var FabricUIManager = require("FabricUIManager");
 var checkPropTypes = require("prop-types/checkPropTypes");
 var ExceptionsManager = require("ExceptionsManager");
 
+/**
+ * Use invariant() to assert state which your program assumes to be true.
+ *
+ * Provide sprintf-style format (only %s is supported) and arguments
+ * to provide information about what broke and what you were
+ * expecting.
+ *
+ * The invariant message will be stripped in production, but the invariant
+ * will remain to ensure logic does not differ in production.
+ */
+
+var validateFormat = function() {};
+
+{
+  validateFormat = function(format) {
+    if (format === undefined) {
+      throw new Error("invariant requires an error message argument");
+    }
+  };
+}
+
+function invariant(condition, format, a, b, c, d, e, f) {
+  validateFormat(format);
+
+  if (!condition) {
+    var error = void 0;
+    if (format === undefined) {
+      error = new Error(
+        "Minified exception occurred; use the non-minified dev environment " +
+          "for the full error message and additional helpful warnings."
+      );
+    } else {
+      var args = [a, b, c, d, e, f];
+      var argIndex = 0;
+      error = new Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      error.name = "Invariant Violation";
+    }
+
+    error.framesToPop = 1; // we don't care about invariant's own frame
+    throw error;
+  }
+}
+
 var invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = false;
   this._caughtError = null;
@@ -499,6 +543,61 @@ function injectEventPluginsByName(injectedNamesToPlugins) {
   }
 }
 
+/**
+ * Similar to invariant but only logs a warning if the condition is not met.
+ * This can be used to log issues in development environments in critical
+ * paths. Removing the logging code for production environments will keep the
+ * same logic and follow the same code paths.
+ */
+
+var warningWithoutStack = function() {};
+
+{
+  warningWithoutStack = function(condition, format) {
+    for (
+      var _len = arguments.length,
+        args = Array(_len > 2 ? _len - 2 : 0),
+        _key = 2;
+      _key < _len;
+      _key++
+    ) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    if (format === undefined) {
+      throw new Error(
+        "`warningWithoutStack(condition, format, ...args)` requires a warning " +
+          "message argument"
+      );
+    }
+    if (condition) {
+      return;
+    }
+    if (typeof console !== "undefined") {
+      var _console;
+
+      (_console = console).error.apply(
+        _console,
+        ["Warning: " + format].concat(args)
+      );
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      var argIndex = 0;
+      var message =
+        "Warning: " +
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        });
+      throw new Error(message);
+    } catch (x) {}
+  };
+}
+
+var warningWithoutStack$1 = warningWithoutStack;
+
 var getFiberCurrentPropsFromNode = null;
 var getInstanceFromNode = null;
 var getNodeFromInstance = null;
@@ -511,7 +610,7 @@ var injection$1 = {
 
     {
       !(getNodeFromInstance && getInstanceFromNode)
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "EventPluginUtils.injection.injectComponentTree(...): Injected " +
               "module is missing getNodeFromInstance or getInstanceFromNode."
@@ -530,15 +629,19 @@ var validateEventDispatches = void 0;
     var listenersIsArr = Array.isArray(dispatchListeners);
     var listenersLen = listenersIsArr
       ? dispatchListeners.length
-      : dispatchListeners ? 1 : 0;
+      : dispatchListeners
+        ? 1
+        : 0;
 
     var instancesIsArr = Array.isArray(dispatchInstances);
     var instancesLen = instancesIsArr
       ? dispatchInstances.length
-      : dispatchInstances ? 1 : 0;
+      : dispatchInstances
+        ? 1
+        : 0;
 
     !(instancesIsArr === listenersIsArr && instancesLen === listenersLen)
-      ? warning(false, "EventPluginUtils: Invalid `event`.")
+      ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.")
       : void 0;
   };
 }
@@ -951,7 +1054,7 @@ var ContextConsumer = 12;
 var ContextProvider = 13;
 var ForwardRef = 14;
 var Profiler = 15;
-var TimeoutComponent = 16;
+var PlaceholderComponent = 16;
 
 function getParent(inst) {
   do {
@@ -1080,7 +1183,9 @@ function listenerAtPhase(inst, event, propagationPhase) {
  */
 function accumulateDirectionalDispatches(inst, phase, event) {
   {
-    !inst ? warning(false, "Dispatching inst must not be null") : void 0;
+    !inst
+      ? warningWithoutStack$1(false, "Dispatching inst must not be null")
+      : void 0;
   }
   var listener = listenerAtPhase(inst, event, phase);
   if (listener) {
@@ -1160,19 +1265,8 @@ function accumulateDirectDispatches(events) {
 
 /* eslint valid-typeof: 0 */
 
-var didWarnForAddedNewProperty = false;
 var EVENT_POOL_SIZE = 10;
 
-var shouldBeReleasedProperties = [
-  "dispatchConfig",
-  "_targetInst",
-  "nativeEvent",
-  "isDefaultPrevented",
-  "isPropagationStopped",
-  "_dispatchListeners",
-  "_dispatchInstances"
-];
-
 /**
  * @interface Event
  * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -1231,6 +1325,8 @@ function SyntheticEvent(
     delete this.nativeEvent;
     delete this.preventDefault;
     delete this.stopPropagation;
+    delete this.isDefaultPrevented;
+    delete this.isPropagationStopped;
   }
 
   this.dispatchConfig = dispatchConfig;
@@ -1336,15 +1432,35 @@ Object.assign(SyntheticEvent.prototype, {
         );
       }
     }
-    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
-      this[shouldBeReleasedProperties[i]] = null;
-    }
+    this.dispatchConfig = null;
+    this._targetInst = null;
+    this.nativeEvent = null;
+    this.isDefaultPrevented = functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    this._dispatchListeners = null;
+    this._dispatchInstances = null;
     {
       Object.defineProperty(
         this,
         "nativeEvent",
         getPooledWarningPropertyDefinition("nativeEvent", null)
       );
+      Object.defineProperty(
+        this,
+        "isDefaultPrevented",
+        getPooledWarningPropertyDefinition(
+          "isDefaultPrevented",
+          functionThatReturnsFalse
+        )
+      );
+      Object.defineProperty(
+        this,
+        "isPropagationStopped",
+        getPooledWarningPropertyDefinition(
+          "isPropagationStopped",
+          functionThatReturnsFalse
+        )
+      );
       Object.defineProperty(
         this,
         "preventDefault",
@@ -1385,51 +1501,6 @@ SyntheticEvent.extend = function(Interface) {
   return Class;
 };
 
-/** Proxying after everything set on SyntheticEvent
- * to resolve Proxy issue on some WebKit browsers
- * in which some Event properties are set to undefined (GH#10010)
- */
-{
-  var isProxySupported =
-    typeof Proxy === "function" &&
-    // https://github.com/facebook/react/issues/12011
-    !Object.isSealed(new Proxy({}, {}));
-
-  if (isProxySupported) {
-    /*eslint-disable no-func-assign */
-    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) {
-            if (
-              prop !== "isPersistent" &&
-              !target.constructor.Interface.hasOwnProperty(prop) &&
-              shouldBeReleasedProperties.indexOf(prop) === -1
-            ) {
-              !(didWarnForAddedNewProperty || target.isPersistent())
-                ? warning(
-                    false,
-                    "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."
-                  )
-                : void 0;
-              didWarnForAddedNewProperty = true;
-            }
-            target[prop] = value;
-            return true;
-          }
-        });
-      }
-    });
-    /*eslint-enable no-func-assign */
-  }
-}
-
 addEventPoolingTo(SyntheticEvent);
 
 /**
@@ -1465,7 +1536,7 @@ function getPooledWarningPropertyDefinition(propName, getVal) {
   function warn(action, result) {
     var warningCondition = false;
     !warningCondition
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "This synthetic event is reused for performance reasons. If you're seeing this, " +
             "you're %s `%s` on a released/nullified synthetic event. %s. " +
@@ -1504,7 +1575,7 @@ function releasePooledEvent(event) {
   var EventConstructor = this;
   invariant(
     event instanceof EventConstructor,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
@@ -1518,14 +1589,12 @@ function addEventPoolingTo(EventConstructor) {
   EventConstructor.release = releasePooledEvent;
 }
 
-var SyntheticEvent$1 = SyntheticEvent;
-
 /**
  * `touchHistory` isn't actually on the native event, but putting it in the
  * interface will ensure that it is cleaned up when pooled/destroyed. The
  * `ResponderEventPlugin` will populate it appropriately.
  */
-var ResponderSyntheticEvent = SyntheticEvent$1.extend({
+var ResponderSyntheticEvent = SyntheticEvent.extend({
   touchHistory: function(nativeEvent) {
     return null; // Actually doesn't even look at the native event.
   }
@@ -1617,7 +1686,7 @@ function getTouchIdentifier(_ref) {
   invariant(identifier != null, "Touch object is missing identifier.");
   {
     !(identifier <= MAX_TOUCH_BANK)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Touch identifier %s is greater than maximum supported %s which causes " +
             "performance issues backfilling array locations for all of the indices.",
@@ -1724,7 +1793,7 @@ var ResponderTouchHistoryStore = {
         {
           var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
           !(activeRecord != null && activeRecord.touchActive)
-            ? warning(false, "Cannot find single active touch.")
+            ? warningWithoutStack$1(false, "Cannot find single active touch.")
             : void 0;
         }
       }
@@ -2279,7 +2348,9 @@ var ResponderEventPlugin = {
       ? eventTypes$1.responderStart
       : isResponderTouchMove
         ? eventTypes$1.responderMove
-        : isResponderTouchEnd ? eventTypes$1.responderEnd : null;
+        : isResponderTouchEnd
+          ? eventTypes$1.responderEnd
+          : null;
 
     if (incrementalTouch) {
       var gesture = ResponderSyntheticEvent.getPooled(
@@ -2302,7 +2373,9 @@ var ResponderEventPlugin = {
       noResponderTouches(nativeEvent);
     var finalTouch = isResponderTerminate
       ? eventTypes$1.responderTerminate
-      : isResponderRelease ? eventTypes$1.responderRelease : null;
+      : isResponderRelease
+        ? eventTypes$1.responderRelease
+        : null;
     if (finalTouch) {
       var finalEvent = ResponderSyntheticEvent.getPooled(
         finalTouch,
@@ -2362,7 +2435,7 @@ var ReactNativeBridgeEventPlugin = {
       'Unsupported top level event type "%s" dispatched',
       topLevelType
     );
-    var event = SyntheticEvent$1.getPooled(
+    var event = SyntheticEvent.getPooled(
       bubbleDispatchConfig || directDispatchConfig,
       targetInst,
       nativeEvent,
@@ -2468,10 +2541,8 @@ function set(key, value) {
   key._reactInternalFiber = value;
 }
 
-var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;
-var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;
+var ReactSharedInternals =
+  React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
 // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
 // nor polyfill, then a plain number is used for performance.
@@ -2490,7 +2561,9 @@ var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 0xeacf;
 var REACT_FORWARD_REF_TYPE = hasSymbol
   ? Symbol.for("react.forward_ref")
   : 0xead0;
-var REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 0xead1;
+var REACT_PLACEHOLDER_TYPE = hasSymbol
+  ? Symbol.for("react.placeholder")
+  : 0xead1;
 
 var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
 var FAUX_ITERATOR_SYMBOL = "@@iterator";
@@ -2508,11 +2581,22 @@ function getIteratorFn(maybeIterable) {
   return null;
 }
 
-function getComponentName(fiber) {
-  var type = fiber.type;
-
+function getComponentName(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+  {
+    if (typeof type.tag === "number") {
+      warningWithoutStack$1(
+        false,
+        "Received an unexpected object in getComponentName(). " +
+          "This is likely a bug in React. Please file an issue."
+      );
+    }
+  }
   if (typeof type === "function") {
-    return type.displayName || type.name;
+    return type.displayName || type.name || null;
   }
   if (typeof type === "string") {
     return type;
@@ -2520,25 +2604,26 @@ function getComponentName(fiber) {
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if (typeof type === "object" && type !== null) {
+  if (typeof type === "object") {
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
-        var functionName = type.render.displayName || type.render.name || "";
+        var renderFn = type.render;
+        var functionName = renderFn.displayName || renderFn.name || "";
         return functionName !== ""
           ? "ForwardRef(" + functionName + ")"
           : "ForwardRef";
@@ -2562,12 +2647,17 @@ var DidCapture = /*            */ 64;
 var Ref = /*                   */ 128;
 var Snapshot = /*              */ 256;
 
+// Update & Callback & Ref & Snapshot
+var LifecycleEffectMask = /*   */ 420;
+
 // Union of all host effects
 var HostEffectMask = /*        */ 511;
 
 var Incomplete = /*            */ 512;
 var ShouldCapture = /*         */ 1024;
 
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+
 var MOUNTING = 1;
 var MOUNTED = 2;
 var UNMOUNTED = 3;
@@ -2607,19 +2697,19 @@ function isFiberMounted(fiber) {
 
 function isMounted(component) {
   {
-    var owner = ReactCurrentOwner.current;
+    var owner = ReactCurrentOwner$1.current;
     if (owner !== null && owner.tag === ClassComponent) {
       var ownerFiber = owner;
       var instance = ownerFiber.stateNode;
       !instance._warnedAboutRefsInRender
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s is accessing isMounted inside its render() function. " +
               "render() should be a pure function of props and state. It should " +
               "never access something that requires stale data from the previous " +
               "render, such as refs. Move this logic to componentDidMount and " +
               "componentDidUpdate instead.",
-            getComponentName(ownerFiber) || "A component"
+            getComponentName(ownerFiber.type) || "A component"
           )
         : void 0;
       instance._warnedAboutRefsInRender = true;
@@ -2897,7 +2987,7 @@ function warnForStyleProps(props, validAttributes) {
 }
 
 // Modules provided by RN:
-var emptyObject$1 = {};
+var emptyObject = {};
 
 /**
  * Create a payload that contains all the updates between two sets of props.
@@ -3301,7 +3391,7 @@ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
  */
 function addProperties(updatePayload, props, validAttributes) {
   // TODO: Fast path
-  return diffProperties(updatePayload, emptyObject$1, props, validAttributes);
+  return diffProperties(updatePayload, emptyObject, props, validAttributes);
 }
 
 /**
@@ -3310,12 +3400,7 @@ function addProperties(updatePayload, props, validAttributes) {
  */
 function clearProperties(updatePayload, prevProps, validAttributes) {
   // TODO: Fast path
-  return diffProperties(
-    updatePayload,
-    prevProps,
-    emptyObject$1,
-    validAttributes
-  );
+  return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
 }
 
 function create(props, validAttributes) {
@@ -3798,6 +3883,10 @@ var now = now$1;
 var scheduleDeferredCallback = scheduleDeferredCallback$1;
 var cancelDeferredCallback = cancelDeferredCallback$1;
 
+var scheduleTimeout = setTimeout;
+var cancelTimeout = clearTimeout;
+var noTimeout = -1;
+
 // -------------------
 //     Persistence
 // -------------------
@@ -3868,22 +3957,27 @@ var describeComponentFrame = function(name, source, ownerName) {
         ":" +
         source.lineNumber +
         ")"
-      : ownerName ? " (created by " + ownerName + ")" : "")
+      : ownerName
+        ? " (created by " + ownerName + ")"
+        : "")
   );
 };
 
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
 function describeFiber(fiber) {
   switch (fiber.tag) {
     case IndeterminateComponent:
     case FunctionalComponent:
     case ClassComponent:
     case HostComponent:
+    case Mode:
       var owner = fiber._debugOwner;
       var source = fiber._debugSource;
-      var name = getComponentName(fiber);
+      var name = getComponentName(fiber.type);
       var ownerName = null;
       if (owner) {
-        ownerName = getComponentName(owner);
+        ownerName = getComponentName(owner.type);
       }
       return describeComponentFrame(name, source, ownerName);
     default:
@@ -3891,73 +3985,66 @@ function describeFiber(fiber) {
   }
 }
 
-// This function can only be called with a work-in-progress fiber and
-// only during begin or complete phase. Do not call it under any other
-// circumstances.
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   var node = workInProgress;
   do {
     info += describeFiber(node);
-    // Otherwise this return pointer might point to the wrong tree:
     node = node.return;
   } while (node);
   return info;
 }
 
-function getCurrentFiberOwnerName() {
+var current = null;
+var phase = null;
+
+function getCurrentFiberOwnerNameInDevOrNull() {
   {
-    var fiber = ReactDebugCurrentFiber.current;
-    if (fiber === null) {
+    if (current === null) {
       return null;
     }
-    var owner = fiber._debugOwner;
+    var owner = current._debugOwner;
     if (owner !== null && typeof owner !== "undefined") {
-      return getComponentName(owner);
+      return getComponentName(owner.type);
     }
   }
   return null;
 }
 
-function getCurrentFiberStackAddendum() {
+function getCurrentFiberStackInDev() {
   {
-    var fiber = ReactDebugCurrentFiber.current;
-    if (fiber === null) {
-      return null;
+    if (current === null) {
+      return "";
     }
     // Safe because if current fiber exists, we are reconciling,
     // and it is guaranteed to be the work-in-progress version.
-    return getStackAddendumByWorkInProgressFiber(fiber);
+    return getStackByFiberInDevAndProd(current);
   }
-  return null;
+  return "";
 }
 
 function resetCurrentFiber() {
-  ReactDebugCurrentFrame.getCurrentStack = null;
-  ReactDebugCurrentFiber.current = null;
-  ReactDebugCurrentFiber.phase = null;
+  {
+    ReactDebugCurrentFrame.getCurrentStack = null;
+    current = null;
+    phase = null;
+  }
 }
 
 function setCurrentFiber(fiber) {
-  ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum;
-  ReactDebugCurrentFiber.current = fiber;
-  ReactDebugCurrentFiber.phase = null;
+  {
+    ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+    current = fiber;
+    phase = null;
+  }
 }
 
-function setCurrentPhase(phase) {
-  ReactDebugCurrentFiber.phase = phase;
+function setCurrentPhase(lifeCyclePhase) {
+  {
+    phase = lifeCyclePhase;
+  }
 }
 
-var ReactDebugCurrentFiber = {
-  current: null,
-  phase: null,
-  resetCurrentFiber: resetCurrentFiber,
-  setCurrentFiber: setCurrentFiber,
-  setCurrentPhase: setCurrentPhase,
-  getCurrentFiberOwnerName: getCurrentFiberOwnerName,
-  getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
-};
-
 var debugRenderPhaseSideEffects = false;
 var debugRenderPhaseSideEffectsForStrictMode = false;
 var enableUserTimingAPI = true;
@@ -4007,9 +4094,9 @@ var formatMarkName = function(markName) {
   return reactEmoji + " " + markName;
 };
 
-var formatLabel = function(label, warning$$1) {
-  var prefix = warning$$1 ? warningEmoji + " " : reactEmoji + " ";
-  var suffix = warning$$1 ? " Warning: " + warning$$1 : "";
+var formatLabel = function(label, warning) {
+  var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+  var suffix = warning ? " Warning: " + warning : "";
   return "" + prefix + label + suffix;
 };
 
@@ -4021,9 +4108,9 @@ var clearMark = function(markName) {
   performance.clearMarks(formatMarkName(markName));
 };
 
-var endMark = function(label, markName, warning$$1) {
+var endMark = function(label, markName, warning) {
   var formattedMarkName = formatMarkName(markName);
-  var formattedLabel = formatLabel(label, warning$$1);
+  var formattedLabel = formatLabel(label, warning);
   try {
     performance.measure(formattedLabel, formattedMarkName);
   } catch (err) {}
@@ -4051,7 +4138,7 @@ var getFiberLabel = function(componentName, isMounted, phase) {
 };
 
 var beginFiberMark = function(fiber, phase) {
-  var componentName = getComponentName(fiber) || "Unknown";
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
@@ -4070,7 +4157,7 @@ var beginFiberMark = function(fiber, phase) {
 };
 
 var clearFiberMark = function(fiber, phase) {
-  var componentName = getComponentName(fiber) || "Unknown";
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
@@ -4078,13 +4165,13 @@ var clearFiberMark = function(fiber, phase) {
   clearMark(markName);
 };
 
-var endFiberMark = function(fiber, phase, warning$$1) {
-  var componentName = getComponentName(fiber) || "Unknown";
+var endFiberMark = function(fiber, phase, warning) {
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
   var markName = getFiberMarkName(label, debugID);
-  endMark(label, markName, warning$$1);
+  endMark(label, markName, warning);
 };
 
 var shouldIgnoreFiber = function(fiber) {
@@ -4176,13 +4263,13 @@ function stopRequestCallbackTimer(didExpire, expirationTime) {
   if (enableUserTimingAPI) {
     if (supportsUserTiming) {
       isWaitingForCallback = false;
-      var warning$$1 = didExpire ? "React was blocked by main thread" : null;
+      var warning = didExpire ? "React was blocked by main thread" : null;
       endMark(
         "(Waiting for async callback... will force flush in " +
           expirationTime +
           " ms)",
         "(Waiting for async callback...)",
-        warning$$1
+        warning
       );
     }
   }
@@ -4240,8 +4327,8 @@ function stopFailedWorkTimer(fiber) {
       return;
     }
     fiber._debugIsCurrentlyTiming = false;
-    var warning$$1 = "An error was thrown inside this error boundary";
-    endFiberMark(fiber, null, warning$$1);
+    var warning = "An error was thrown inside this error boundary";
+    endFiberMark(fiber, null, warning);
   }
 }
 
@@ -4265,10 +4352,10 @@ function stopPhaseTimer() {
       return;
     }
     if (currentPhase !== null && currentPhaseFiber !== null) {
-      var warning$$1 = hasScheduledUpdateInCurrentPhase
+      var warning = hasScheduledUpdateInCurrentPhase
         ? "Scheduled a cascading update"
         : null;
-      endFiberMark(currentPhaseFiber, currentPhase, warning$$1);
+      endFiberMark(currentPhaseFiber, currentPhase, warning);
     }
     currentPhase = null;
     currentPhaseFiber = null;
@@ -4295,17 +4382,17 @@ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
     if (!supportsUserTiming) {
       return;
     }
-    var warning$$1 = null;
+    var warning = null;
     if (interruptedBy !== null) {
       if (interruptedBy.tag === HostRoot) {
-        warning$$1 = "A top-level update interrupted the previous render";
+        warning = "A top-level update interrupted the previous render";
       } else {
-        var componentName = getComponentName(interruptedBy) || "Unknown";
-        warning$$1 =
+        var componentName = getComponentName(interruptedBy.type) || "Unknown";
+        warning =
           "An update to " + componentName + " interrupted the previous render";
       }
     } else if (commitCountInCurrentWorkLoop > 1) {
-      warning$$1 = "There were cascading updates";
+      warning = "There were cascading updates";
     }
     commitCountInCurrentWorkLoop = 0;
     var label = didCompleteRoot
@@ -4313,7 +4400,7 @@ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
       : "(React Tree Reconciliation: Yielded)";
     // Pause any measurements until the next loop.
     pauseTimers();
-    endMark(label, "(React Tree Reconciliation)", warning$$1);
+    endMark(label, "(React Tree Reconciliation)", warning);
   }
 }
 
@@ -4335,18 +4422,18 @@ function stopCommitTimer() {
       return;
     }
 
-    var warning$$1 = null;
+    var warning = null;
     if (hasScheduledUpdateInCurrentCommit) {
-      warning$$1 = "Lifecycle hook scheduled a cascading update";
+      warning = "Lifecycle hook scheduled a cascading update";
     } else if (commitCountInCurrentWorkLoop > 0) {
-      warning$$1 = "Caused by a cascading update in earlier commit";
+      warning = "Caused by a cascading update in earlier commit";
     }
     hasScheduledUpdateInCurrentCommit = false;
     commitCountInCurrentWorkLoop++;
     isCommitting = false;
     labelsInCurrentCommit.clear();
 
-    endMark("(Committing Changes)", "(Committing Changes)", warning$$1);
+    endMark("(Committing Changes)", "(Committing Changes)", warning);
   }
 }
 
@@ -4444,14 +4531,14 @@ function createCursor(defaultValue) {
 function pop(cursor, fiber) {
   if (index < 0) {
     {
-      warning(false, "Unexpected pop.");
+      warningWithoutStack$1(false, "Unexpected pop.");
     }
     return;
   }
 
   {
     if (fiber !== fiberStack[index]) {
-      warning(false, "Unexpected Fiber popped.");
+      warningWithoutStack$1(false, "Unexpected Fiber popped.");
     }
   }
 
@@ -4481,7 +4568,7 @@ function push(cursor, value, fiber) {
 function checkThatStackIsEmpty() {
   {
     if (index !== -1) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected an empty stack. Something was not reset properly."
       );
@@ -4503,14 +4590,19 @@ var warnedAboutMissingGetChildContext = void 0;
   warnedAboutMissingGetChildContext = {};
 }
 
+var emptyContextObject = {};
+{
+  Object.freeze(emptyContextObject);
+}
+
 // A cursor to the current merged context object on the stack.
-var contextStackCursor = createCursor(emptyObject);
+var contextStackCursor = createCursor(emptyContextObject);
 // A cursor to a boolean indicating whether the context has changed.
 var didPerformWorkStackCursor = createCursor(false);
 // Keep track of the previous context object that was on the stack.
 // We use this to get access to the parent context after we have already
 // pushed the next context provider, and now need to merge their contexts.
-var previousContext = emptyObject;
+var previousContext = emptyContextObject;
 
 function getUnmaskedContext(workInProgress) {
   var hasOwnContext = isContextProvider(workInProgress);
@@ -4534,7 +4626,7 @@ function getMaskedContext(workInProgress, unmaskedContext) {
   var type = workInProgress.type;
   var contextTypes = type.contextTypes;
   if (!contextTypes) {
-    return emptyObject;
+    return emptyContextObject;
   }
 
   // Avoid recreating masked context unless unmasked context has changed.
@@ -4554,13 +4646,13 @@ function getMaskedContext(workInProgress, unmaskedContext) {
   }
 
   {
-    var name = getComponentName(workInProgress) || "Unknown";
+    var name = getComponentName(type) || "Unknown";
     checkPropTypes(
       contextTypes,
       context,
       "context",
       name,
-      ReactDebugCurrentFiber.getCurrentFiberStackAddendum
+      getCurrentFiberStackInDev
     );
   }
 
@@ -4601,7 +4693,7 @@ function popTopLevelContextObject(fiber) {
 
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "Unexpected context found on stack. " +
       "This error is likely caused by a bug in React. Please file an issue."
   );
@@ -4612,17 +4704,18 @@ function pushTopLevelContextObject(fiber, context, didChange) {
 
 function processChildContext(fiber, parentContext) {
   var instance = fiber.stateNode;
-  var childContextTypes = fiber.type.childContextTypes;
+  var type = fiber.type;
+  var childContextTypes = type.childContextTypes;
 
   // TODO (bvaughn) Replace this behavior with an invariant() in the future.
   // It has only been added in Fiber to match the (unintentional) behavior in Stack.
   if (typeof instance.getChildContext !== "function") {
     {
-      var componentName = getComponentName(fiber) || "Unknown";
+      var componentName = getComponentName(type) || "Unknown";
 
       if (!warnedAboutMissingGetChildContext[componentName]) {
         warnedAboutMissingGetChildContext[componentName] = true;
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.childContextTypes is specified but there is no getChildContext() method " +
             "on the instance. You can either define getChildContext() on %s or remove " +
@@ -4637,24 +4730,24 @@ function processChildContext(fiber, parentContext) {
 
   var childContext = void 0;
   {
-    ReactDebugCurrentFiber.setCurrentPhase("getChildContext");
+    setCurrentPhase("getChildContext");
   }
   startPhaseTimer(fiber, "getChildContext");
   childContext = instance.getChildContext();
   stopPhaseTimer();
   {
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
   for (var contextKey in childContext) {
     invariant(
       contextKey in childContextTypes,
       '%s.getChildContext(): key "%s" is not defined in childContextTypes.',
-      getComponentName(fiber) || "Unknown",
+      getComponentName(type) || "Unknown",
       contextKey
     );
   }
   {
-    var name = getComponentName(fiber) || "Unknown";
+    var name = getComponentName(type) || "Unknown";
     checkPropTypes(
       childContextTypes,
       childContext,
@@ -4665,7 +4758,7 @@ function processChildContext(fiber, parentContext) {
       // context from the parent component instance. The stack will be missing
       // because it's outside of the reconciliation, and so the pointer has not
       // been set. This is rare and doesn't matter. We'll also remove that API.
-      ReactDebugCurrentFiber.getCurrentFiberStackAddendum
+      getCurrentFiberStackInDev
     );
   }
 
@@ -4683,7 +4776,7 @@ function pushContextProvider(workInProgress) {
   // and replace it on the stack later when invalidating the context.
   var memoizedMergedChildContext =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
 
   // Remember the parent context so we can merge with it later.
   // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
@@ -4751,14 +4844,96 @@ function findCurrentUnmaskedContext(fiber) {
   return node.stateNode.context;
 }
 
+var onCommitFiberRoot = null;
+var onCommitFiberUnmount = null;
+var hasLoggedError = false;
+
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {
+      if (true && !hasLoggedError) {
+        hasLoggedError = true;
+        warningWithoutStack$1(
+          false,
+          "React DevTools encountered an error: %s",
+          err
+        );
+      }
+    }
+  };
+}
+
+var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+    // No DevTools
+    return false;
+  }
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+  if (!hook.supportsFiber) {
+    {
+      warningWithoutStack$1(
+        false,
+        "The installed version of React DevTools is too old and will not work " +
+          "with the current version of React. Please update React DevTools. " +
+          "https://fb.me/react-devtools"
+      );
+    }
+    // DevTools exists, even though it doesn't support Fiber.
+    return true;
+  }
+  try {
+    var rendererID = hook.inject(internals);
+    // We have successfully injected, so now it is safe to set up hooks.
+    onCommitFiberRoot = catchErrors(function(root) {
+      return hook.onCommitFiberRoot(rendererID, root);
+    });
+    onCommitFiberUnmount = catchErrors(function(fiber) {
+      return hook.onCommitFiberUnmount(rendererID, fiber);
+    });
+  } catch (err) {
+    // Catch all errors because it is unsafe to throw during initialization.
+    {
+      warningWithoutStack$1(
+        false,
+        "React DevTools encountered an error: %s.",
+        err
+      );
+    }
+  }
+  // DevTools exists
+  return true;
+}
+
+function onCommitRoot(root) {
+  if (typeof onCommitFiberRoot === "function") {
+    onCommitFiberRoot(root);
+  }
+}
+
+function onCommitUnmount(fiber) {
+  if (typeof onCommitFiberUnmount === "function") {
+    onCommitFiberUnmount(fiber);
+  }
+}
+
 // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
 // Math.pow(2, 30) - 1
 // 0b111111111111111111111111111111
-var MAX_SIGNED_31_BIT_INT = 1073741823;
+var maxSigned31BitInt = 1073741823;
 
 var NoWork = 0;
 var Sync = 1;
-var Never = MAX_SIGNED_31_BIT_INT;
+var Never = maxSigned31BitInt;
 
 var UNIT_SIZE = 10;
 var MAGIC_NUMBER_OFFSET = 2;
@@ -4787,6 +4962,39 @@ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
   );
 }
 
+var LOW_PRIORITY_EXPIRATION = 5000;
+var LOW_PRIORITY_BATCH_SIZE = 250;
+
+function computeAsyncExpiration(currentTime) {
+  return computeExpirationBucket(
+    currentTime,
+    LOW_PRIORITY_EXPIRATION,
+    LOW_PRIORITY_BATCH_SIZE
+  );
+}
+
+// We intentionally set a higher expiration time for interactive updates in
+// dev than in production.
+//
+// If the main thread is being blocked so long that you hit the expiration,
+// it's a problem that could be solved with better scheduling.
+//
+// People will be more likely to notice this and fix it with the long
+// expiration time in development.
+//
+// In production we opt for better UX at the risk of masking scheduling
+// problems, by expiring fast.
+var HIGH_PRIORITY_EXPIRATION = 500;
+var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+function computeInteractiveExpiration(currentTime) {
+  return computeExpirationBucket(
+    currentTime,
+    HIGH_PRIORITY_EXPIRATION,
+    HIGH_PRIORITY_BATCH_SIZE
+  );
+}
+
 var NoContext = 0;
 var AsyncMode = 1;
 var StrictMode = 2;
@@ -4839,6 +5047,7 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.memoizedProps = null;
   this.updateQueue = null;
   this.memoizedState = null;
+  this.firstContextDependency = null;
 
   this.mode = mode;
 
@@ -4850,14 +5059,15 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.lastEffect = null;
 
   this.expirationTime = NoWork;
+  this.childExpirationTime = NoWork;
 
   this.alternate = null;
 
   if (enableProfilerTimer) {
     this.actualDuration = 0;
     this.actualStartTime = 0;
-    this.selfBaseTime = 0;
-    this.treeBaseTime = 0;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
   }
 
   {
@@ -4942,12 +5152,21 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
     }
   }
 
-  workInProgress.expirationTime = expirationTime;
+  // Don't touching the subtree's expiration time, which has not changed.
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  if (pendingProps !== current.pendingProps) {
+    // This fiber has new props.
+    workInProgress.expirationTime = expirationTime;
+  } else {
+    // This fiber's props have not changed.
+    workInProgress.expirationTime = current.expirationTime;
+  }
 
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
 
   // These will be overridden during the parent's reconciliation
   workInProgress.sibling = current.sibling;
@@ -4955,8 +5174,8 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
   workInProgress.ref = current.ref;
 
   if (enableProfilerTimer) {
-    workInProgress.selfBaseTime = current.selfBaseTime;
-    workInProgress.treeBaseTime = current.treeBaseTime;
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
   }
 
   return workInProgress;
@@ -4964,6 +5183,14 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
 
 function createHostRootFiber(isAsync) {
   var mode = isAsync ? AsyncMode | StrictMode : NoContext;
+
+  if (enableProfilerTimer && isDevToolsPresent) {
+    // Always collect profile timings when DevTools are present.
+    // This enables DevTools to start capturing timing at any point–
+    // Without some nodes in the tree having empty base times.
+    mode |= ProfileMode;
+  }
+
   return createFiber(HostRoot, null, null, mode);
 }
 
@@ -5002,11 +5229,8 @@ function createFiberFromElement(element, mode, expirationTime) {
         break;
       case REACT_PROFILER_TYPE:
         return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
-      case REACT_TIMEOUT_TYPE:
-        fiberTag = TimeoutComponent;
-        // Suspense does not require async, but its children should be strict
-        // mode compatible.
-        mode |= StrictMode;
+      case REACT_PLACEHOLDER_TYPE:
+        fiberTag = PlaceholderComponent;
         break;
       default:
         fiberTag = getFiberTagFromObjectType(type, owner);
@@ -5052,7 +5276,7 @@ function getFiberTagFromObjectType(type, owner) {
             "it's defined in, or you might have mixed up default and " +
             "named imports.";
         }
-        var ownerName = owner ? getComponentName(owner) : null;
+        var ownerName = owner ? getComponentName(owner.type) : null;
         if (ownerName) {
           info += "\n\nCheck the render method of `" + ownerName + "`.";
         }
@@ -5146,18 +5370,20 @@ function assignFiberPropertiesInDEV(target, source) {
   target.memoizedProps = source.memoizedProps;
   target.updateQueue = source.updateQueue;
   target.memoizedState = source.memoizedState;
+  target.firstContextDependency = source.firstContextDependency;
   target.mode = source.mode;
   target.effectTag = source.effectTag;
   target.nextEffect = source.nextEffect;
   target.firstEffect = source.firstEffect;
   target.lastEffect = source.lastEffect;
   target.expirationTime = source.expirationTime;
+  target.childExpirationTime = source.childExpirationTime;
   target.alternate = source.alternate;
   if (enableProfilerTimer) {
     target.actualDuration = source.actualDuration;
     target.actualStartTime = source.actualStartTime;
-    target.selfBaseTime = source.selfBaseTime;
-    target.treeBaseTime = source.treeBaseTime;
+    target.selfBaseDuration = source.selfBaseDuration;
+    target.treeBaseDuration = source.treeBaseDuration;
   }
   target._debugID = source._debugID;
   target._debugSource = source._debugSource;
@@ -5187,6 +5413,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
 
     pendingCommitExpirationTime: NoWork,
     finishedWork: null,
+    timeoutHandle: noTimeout,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -5199,78 +5426,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   return root;
 }
 
-var onCommitFiberRoot = null;
-var onCommitFiberUnmount = null;
-var hasLoggedError = false;
-
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {
-      if (true && !hasLoggedError) {
-        hasLoggedError = true;
-        warning(false, "React DevTools encountered an error: %s", err);
-      }
-    }
-  };
-}
-
-function injectInternals(internals) {
-  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
-    // No DevTools
-    return false;
-  }
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled) {
-    // This isn't a real property on the hook, but it can be set to opt out
-    // of DevTools integration and associated warnings and logs.
-    // https://github.com/facebook/react/issues/3877
-    return true;
-  }
-  if (!hook.supportsFiber) {
-    {
-      warning(
-        false,
-        "The installed version of React DevTools is too old and will not work " +
-          "with the current version of React. Please update React DevTools. " +
-          "https://fb.me/react-devtools"
-      );
-    }
-    // DevTools exists, even though it doesn't support Fiber.
-    return true;
-  }
-  try {
-    var rendererID = hook.inject(internals);
-    // We have successfully injected, so now it is safe to set up hooks.
-    onCommitFiberRoot = catchErrors(function(root) {
-      return hook.onCommitFiberRoot(rendererID, root);
-    });
-    onCommitFiberUnmount = catchErrors(function(fiber) {
-      return hook.onCommitFiberUnmount(rendererID, fiber);
-    });
-  } catch (err) {
-    // Catch all errors because it is unsafe to throw during initialization.
-    {
-      warning(false, "React DevTools encountered an error: %s.", err);
-    }
-  }
-  // DevTools exists
-  return true;
-}
-
-function onCommitRoot(root) {
-  if (typeof onCommitFiberRoot === "function") {
-    onCommitFiberRoot(root);
-  }
-}
-
-function onCommitUnmount(fiber) {
-  if (typeof onCommitFiberUnmount === "function") {
-    onCommitFiberUnmount(fiber);
-  }
-}
-
 /**
  * Forked from fbjs/warning:
  * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
@@ -5319,7 +5474,7 @@ var lowPriorityWarning = function() {};
   lowPriorityWarning = function(condition, format) {
     if (format === undefined) {
       throw new Error(
-        "`warning(condition, format, ...args)` requires a warning " +
+        "`lowPriorityWarning(condition, format, ...args)` requires a warning " +
           "message argument"
       );
     }
@@ -5397,7 +5552,7 @@ var ReactStrictModeWarnings = {
         if (lifecycleWarnings.length > 0) {
           var componentNames = new Set();
           lifecycleWarnings.forEach(function(fiber) {
-            componentNames.add(getComponentName(fiber) || "Component");
+            componentNames.add(getComponentName(fiber.type) || "Component");
             didWarnAboutUnsafeLifecycles.add(fiber.type);
           });
 
@@ -5414,11 +5569,9 @@ var ReactStrictModeWarnings = {
       });
 
       if (lifecyclesWarningMesages.length > 0) {
-        var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(
-          strictRoot
-        );
+        var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
 
-        warning(
+        warningWithoutStack$1(
           false,
           "Unsafe lifecycle methods were found within a strict-mode tree:%s" +
             "\n\n%s" +
@@ -5451,7 +5604,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillMountWarnings.length > 0) {
       var uniqueNames = new Set();
       pendingComponentWillMountWarnings.forEach(function(fiber) {
-        uniqueNames.add(getComponentName(fiber) || "Component");
+        uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5474,7 +5627,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillReceivePropsWarnings.length > 0) {
       var _uniqueNames = new Set();
       pendingComponentWillReceivePropsWarnings.forEach(function(fiber) {
-        _uniqueNames.add(getComponentName(fiber) || "Component");
+        _uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5496,7 +5649,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillUpdateWarnings.length > 0) {
       var _uniqueNames2 = new Set();
       pendingComponentWillUpdateWarnings.forEach(function(fiber) {
-        _uniqueNames2.add(getComponentName(fiber) || "Component");
+        _uniqueNames2.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5553,7 +5706,7 @@ var ReactStrictModeWarnings = {
   ) {
     var strictRoot = findStrictRoot(fiber);
     if (strictRoot === null) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected to find a StrictMode component in a strict mode tree. " +
           "This error is likely caused by a bug in React. Please file an issue."
@@ -5620,7 +5773,7 @@ var ReactStrictModeWarnings = {
   ) {
     var strictRoot = findStrictRoot(fiber);
     if (strictRoot === null) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected to find a StrictMode component in a strict mode tree. " +
           "This error is likely caused by a bug in React. Please file an issue."
@@ -5652,16 +5805,14 @@ var ReactStrictModeWarnings = {
     pendingLegacyContextWarning.forEach(function(fiberArray, strictRoot) {
       var uniqueNames = new Set();
       fiberArray.forEach(function(fiber) {
-        uniqueNames.add(getComponentName(fiber) || "Component");
+        uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutLegacyContext.add(fiber.type);
       });
 
       var sortedNames = setToSortedString(uniqueNames);
-      var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(
-        strictRoot
-      );
+      var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
 
-      warning(
+      warningWithoutStack$1(
         false,
         "Legacy context API has been detected within a strict-mode tree: %s" +
           "\n\nPlease update the following components: %s" +
@@ -5684,7 +5835,9 @@ var ReactFiberInstrumentation = {
 
 var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;
 
-// TODO: Offscreen updates
+// TODO: Offscreen updates should never suspend. However, a promise that
+// suspended inside an offscreen subtree should be able to ping at the priority
+// of the outer render.
 
 function markPendingPriorityLevel(root, expirationTime) {
   // If there's a gap between completing a failed root and retrying it,
@@ -5709,10 +5862,10 @@ function markPendingPriorityLevel(root, expirationTime) {
       }
     }
   }
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
 
-function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
+function markCommittedPriorityLevels(root, earliestRemainingTime) {
   root.didError = false;
 
   if (earliestRemainingTime === NoWork) {
@@ -5722,7 +5875,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     root.earliestSuspendedTime = NoWork;
     root.latestSuspendedTime = NoWork;
     root.latestPingedTime = NoWork;
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -5751,7 +5904,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // There's no suspended work. Treat the earliest remaining level as a
     // pending level.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -5766,7 +5919,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // There's no suspended work. Treat the earliest remaining level as a
     // pending level.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -5774,31 +5927,41 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // The earliest remaining time is earlier than all the suspended work.
     // Treat it as a pending update.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
   // The earliest remaining time falls within the range of known suspended
   // levels. We should treat this as suspended work.
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(NoWork, root);
 }
 
-function hasLowerPriorityWork(root, renderExpirationTime) {
+function hasLowerPriorityWork(root, erroredExpirationTime) {
+  var latestPendingTime = root.latestPendingTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  var latestPingedTime = root.latestPingedTime;
   return (
-    renderExpirationTime !== root.latestPendingTime &&
-    renderExpirationTime !== root.latestSuspendedTime
+    (latestPendingTime !== NoWork &&
+      latestPendingTime > erroredExpirationTime) ||
+    (latestSuspendedTime !== NoWork &&
+      latestSuspendedTime > erroredExpirationTime) ||
+    (latestPingedTime !== NoWork && latestPingedTime > erroredExpirationTime)
   );
 }
 
-function markSuspendedPriorityLevel(root, suspendedTime, didError) {
-  if (didError && !hasLowerPriorityWork(root, suspendedTime)) {
-    // TODO: When we add back resuming, we need to ensure the progressed work
-    // is thrown out and not reused during the restarted render. One way to
-    // invalidate the progressed work is to restart at expirationTime + 1.
-    root.didError = true;
-    findNextPendingPriorityLevel(root);
-    return;
-  }
+function isPriorityLevelSuspended(root, expirationTime) {
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  return (
+    earliestSuspendedTime !== NoWork &&
+    expirationTime >= earliestSuspendedTime &&
+    expirationTime <= latestSuspendedTime
+  );
+}
+
+function markSuspendedPriorityLevel(root, suspendedTime) {
+  root.didError = false;
+  clearPing(root, suspendedTime);
 
   // First, check the known pending levels and update them if needed.
   var earliestPendingTime = root.earliestPendingTime;
@@ -5818,15 +5981,9 @@ function markSuspendedPriorityLevel(root, suspendedTime, didError) {
     root.latestPendingTime = earliestPendingTime;
   }
 
-  // Next, if we're working on the lowest known suspended level, clear the ping.
-  // TODO: What if a promise suspends and pings before the root completes?
-  var latestSuspendedTime = root.latestSuspendedTime;
-  if (latestSuspendedTime === suspendedTime) {
-    root.latestPingedTime = NoWork;
-  }
-
   // Finally, update the known suspended levels.
   var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
   if (earliestSuspendedTime === NoWork) {
     // No other suspended levels.
     root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
@@ -5839,44 +5996,86 @@ function markSuspendedPriorityLevel(root, suspendedTime, didError) {
       root.latestSuspendedTime = suspendedTime;
     }
   }
-  findNextPendingPriorityLevel(root);
+
+  findNextExpirationTimeToWorkOn(suspendedTime, root);
 }
 
 function markPingedPriorityLevel(root, pingedTime) {
-  var latestSuspendedTime = root.latestSuspendedTime;
-  if (latestSuspendedTime !== NoWork && latestSuspendedTime <= pingedTime) {
-    var latestPingedTime = root.latestPingedTime;
-    if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
-      root.latestPingedTime = pingedTime;
-    }
+  root.didError = false;
+
+  // TODO: When we add back resuming, we need to ensure the progressed work
+  // is thrown out and not reused during the restarted render. One way to
+  // invalidate the progressed work is to restart at expirationTime + 1.
+  var latestPingedTime = root.latestPingedTime;
+  if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
+    root.latestPingedTime = pingedTime;
   }
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(pingedTime, root);
 }
 
-function findNextPendingPriorityLevel(root) {
-  var earliestSuspendedTime = root.earliestSuspendedTime;
+function clearPing(root, completedTime) {
+  // TODO: Track whether the root was pinged during the render phase. If so,
+  // we need to make sure we don't lose track of it.
+  var latestPingedTime = root.latestPingedTime;
+  if (latestPingedTime !== NoWork && latestPingedTime <= completedTime) {
+    root.latestPingedTime = NoWork;
+  }
+}
+
+function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+  var earliestExpirationTime = renderExpirationTime;
+
   var earliestPendingTime = root.earliestPendingTime;
-  var nextExpirationTimeToWorkOn = void 0;
-  var expirationTime = void 0;
-  if (earliestSuspendedTime === NoWork) {
-    // Fast path. There's no suspended work.
-    nextExpirationTimeToWorkOn = expirationTime = earliestPendingTime;
-  } else if (earliestPendingTime !== NoWork) {
-    // Check if there's known pending work.
-    nextExpirationTimeToWorkOn = earliestPendingTime;
-    expirationTime =
-      earliestSuspendedTime < earliestPendingTime
-        ? earliestSuspendedTime
-        : earliestPendingTime;
-  } else {
-    // Finally, if a suspended level was pinged, work on that. Otherwise there's
-    // nothing to work on.
-    nextExpirationTimeToWorkOn = expirationTime = root.latestPingedTime;
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  if (
+    earliestExpirationTime === NoWork ||
+    (earliestPendingTime !== NoWork &&
+      earliestPendingTime < earliestExpirationTime)
+  ) {
+    earliestExpirationTime = earliestPendingTime;
+  }
+  if (
+    earliestExpirationTime === NoWork ||
+    (earliestSuspendedTime !== NoWork &&
+      earliestSuspendedTime < earliestExpirationTime)
+  ) {
+    earliestExpirationTime = earliestSuspendedTime;
+  }
+  return earliestExpirationTime;
+}
+
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  var earliestPendingTime = root.earliestPendingTime;
+  var latestPingedTime = root.latestPingedTime;
+
+  // Work on the earliest pending time. Failing that, work on the latest
+  // pinged time.
+  var nextExpirationTimeToWorkOn =
+    earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+  // If there is no pending or pinted work, check if there's suspended work
+  // that's lower priority than what we just completed.
+  if (
+    nextExpirationTimeToWorkOn === NoWork &&
+    (completedExpirationTime === NoWork ||
+      latestSuspendedTime > completedExpirationTime)
+  ) {
+    // The lowest priority suspended work is the work most likely to be
+    // committed next. Let's start rendering it again, so that if it times out,
+    // it's ready to commit.
+    nextExpirationTimeToWorkOn = latestSuspendedTime;
   }
 
-  if (root.didError) {
-    // Revert to synchronous mode.
-    expirationTime = Sync;
+  var expirationTime = nextExpirationTimeToWorkOn;
+  if (
+    expirationTime !== NoWork &&
+    earliestSuspendedTime !== NoWork &&
+    earliestSuspendedTime < expirationTime
+  ) {
+    // Expire using the earliest known expiration time.
+    expirationTime = earliestSuspendedTime;
   }
 
   root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
@@ -5983,7 +6182,6 @@ var resetCurrentlyProcessingQueue = void 0;
 
 function createUpdateQueue(baseState) {
   var queue = {
-    expirationTime: NoWork,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -5999,7 +6197,6 @@ function createUpdateQueue(baseState) {
 
 function cloneUpdateQueue(currentQueue) {
   var queue = {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -6031,7 +6228,7 @@ function createUpdate(expirationTime) {
   };
 }
 
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   // Append the update to the end of the list.
   if (queue.lastUpdate === null) {
     // Queue is empty
@@ -6040,17 +6237,9 @@ function appendUpdateToQueue(queue, update, expirationTime) {
     queue.lastUpdate.next = update;
     queue.lastUpdate = update;
   }
-  if (
-    queue.expirationTime === NoWork ||
-    queue.expirationTime > expirationTime
-  ) {
-    // The incoming update has the earliest expiration of any update in the
-    // queue. Update the queue's expiration time.
-    queue.expirationTime = expirationTime;
-  }
 }
 
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   // Update queues are created lazily.
   var alternate = fiber.alternate;
   var queue1 = void 0;
@@ -6088,19 +6277,19 @@ function enqueueUpdate(fiber, update, expirationTime) {
   }
   if (queue2 === null || queue1 === queue2) {
     // There's only a single queue.
-    appendUpdateToQueue(queue1, update, expirationTime);
+    appendUpdateToQueue(queue1, update);
   } else {
     // There are two queues. We need to append the update to both queues,
     // while accounting for the persistent structure of the list — we don't
     // want the same update to be added multiple times.
     if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
       // One of the queues is not empty. We must add the update to both queues.
-      appendUpdateToQueue(queue1, update, expirationTime);
-      appendUpdateToQueue(queue2, update, expirationTime);
+      appendUpdateToQueue(queue1, update);
+      appendUpdateToQueue(queue2, update);
     } else {
       // Both queues are non-empty. The last update is the same in both lists,
       // because of structural sharing. So, only append to one of the lists.
-      appendUpdateToQueue(queue1, update, expirationTime);
+      appendUpdateToQueue(queue1, update);
       // But we still need to update the `lastUpdate` pointer of queue2.
       queue2.lastUpdate = update;
     }
@@ -6113,7 +6302,7 @@ function enqueueUpdate(fiber, update, expirationTime) {
         (queue2 !== null && currentlyProcessingQueue === queue2)) &&
       !didWarnUpdateInsideUpdate
     ) {
-      warning(
+      warningWithoutStack$1(
         false,
         "An update (setState, replaceState, or forceUpdate) was scheduled " +
           "from inside an update function. Update functions should be pure, " +
@@ -6125,7 +6314,7 @@ function enqueueUpdate(fiber, update, expirationTime) {
   }
 }
 
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   // Captured updates go into a separate list, and only on the work-in-
   // progress queue.
   var workInProgressQueue = workInProgress.updateQueue;
@@ -6151,14 +6340,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     workInProgressQueue.lastCapturedUpdate.next = update;
     workInProgressQueue.lastCapturedUpdate = update;
   }
-  if (
-    workInProgressQueue.expirationTime === NoWork ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  ) {
-    // The incoming update has the earliest expiration of any update in the
-    // queue. Update the queue's expiration time.
-    workInProgressQueue.expirationTime = renderExpirationTime;
-  }
 }
 
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
@@ -6248,14 +6429,6 @@ function processUpdateQueue(
 ) {
   hasForceUpdate = false;
 
-  if (
-    queue.expirationTime === NoWork ||
-    queue.expirationTime > renderExpirationTime
-  ) {
-    // Insufficient priority. Bailout.
-    return;
-  }
-
   queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
 
   {
@@ -6387,8 +6560,15 @@ function processUpdateQueue(
   queue.baseState = newBaseState;
   queue.firstUpdate = newFirstUpdate;
   queue.firstCapturedUpdate = newFirstCapturedUpdate;
-  queue.expirationTime = newExpirationTime;
 
+  // Set the remaining expiration time to be whatever is remaining in the queue.
+  // This should be fine because the only two other things that contribute to
+  // expiration time are props and context. We're already in the middle of the
+  // begin phase by the time we start processing the queue, so we've already
+  // dealt with the props. Context in components that specify
+  // shouldComponentUpdate is tricky; but we'll have to account for
+  // that regardless.
+  workInProgress.expirationTime = newExpirationTime;
   workInProgress.memoizedState = resultState;
 
   {
@@ -6464,11 +6644,10 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
 
-var providerCursor = createCursor(null);
 var valueCursor = createCursor(null);
 var changedBitsCursor = createCursor(0);
 
@@ -6478,13 +6657,24 @@ var rendererSigil = void 0;
   rendererSigil = {};
 }
 
+var currentlyRenderingFiber = null;
+var lastContextDependency = null;
+var lastContextWithAllBitsObserved = null;
+
+function resetContextDependences() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastContextWithAllBitsObserved = null;
+}
+
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
 
   if (isPrimaryRenderer) {
     push(changedBitsCursor, context._changedBits, providerFiber);
     push(valueCursor, context._currentValue, providerFiber);
-    push(providerCursor, providerFiber, providerFiber);
 
     context._currentValue = providerFiber.pendingProps.value;
     context._changedBits = providerFiber.stateNode;
@@ -6494,7 +6684,7 @@ function pushProvider(providerFiber) {
         context._currentRenderer === null ||
         context._currentRenderer === rendererSigil
       )
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "Detected multiple renderers concurrently rendering the " +
               "same context provider. This is currently unsupported."
@@ -6505,7 +6695,6 @@ function pushProvider(providerFiber) {
   } else {
     push(changedBitsCursor, context._changedBits2, providerFiber);
     push(valueCursor, context._currentValue2, providerFiber);
-    push(providerCursor, providerFiber, providerFiber);
 
     context._currentValue2 = providerFiber.pendingProps.value;
     context._changedBits2 = providerFiber.stateNode;
@@ -6515,7 +6704,7 @@ function pushProvider(providerFiber) {
         context._currentRenderer2 === null ||
         context._currentRenderer2 === rendererSigil
       )
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "Detected multiple renderers concurrently rendering the " +
               "same context provider. This is currently unsupported."
@@ -6530,7 +6719,6 @@ function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current;
   var currentValue = valueCursor.current;
 
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
 
@@ -6544,12 +6732,198 @@ function popProvider(providerFiber) {
   }
 }
 
-function getContextCurrentValue(context) {
-  return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
+  while (fiber !== null) {
+    var nextFiber = void 0;
+
+    // Visit this fiber.
+    var dependency = fiber.firstContextDependency;
+    if (dependency !== null) {
+      do {
+        // Check if the context matches.
+        if (
+          dependency.context === context &&
+          (dependency.observedBits & changedBits) !== 0
+        ) {
+          // Match! Schedule an update on this fiber.
+          if (
+            fiber.expirationTime === NoWork ||
+            fiber.expirationTime > renderExpirationTime
+          ) {
+            fiber.expirationTime = renderExpirationTime;
+          }
+          var alternate = fiber.alternate;
+          if (
+            alternate !== null &&
+            (alternate.expirationTime === NoWork ||
+              alternate.expirationTime > renderExpirationTime)
+          ) {
+            alternate.expirationTime = renderExpirationTime;
+          }
+          // Update the child expiration time of all the ancestors, including
+          // the alternates.
+          var node = fiber.return;
+          while (node !== null) {
+            alternate = node.alternate;
+            if (
+              node.childExpirationTime === NoWork ||
+              node.childExpirationTime > renderExpirationTime
+            ) {
+              node.childExpirationTime = renderExpirationTime;
+              if (
+                alternate !== null &&
+                (alternate.childExpirationTime === NoWork ||
+                  alternate.childExpirationTime > renderExpirationTime)
+              ) {
+                alternate.childExpirationTime = renderExpirationTime;
+              }
+            } else if (
+              alternate !== null &&
+              (alternate.childExpirationTime === NoWork ||
+                alternate.childExpirationTime > renderExpirationTime)
+            ) {
+              alternate.childExpirationTime = renderExpirationTime;
+            } else {
+              // Neither alternate was updated, which means the rest of the
+              // ancestor path already has sufficient priority.
+              break;
+            }
+            node = node.return;
+          }
+          // Don't scan deeper than a matching consumer. When we render the
+          // consumer, we'll continue scanning from that point. This way the
+          // scanning work is time-sliced.
+          nextFiber = null;
+        } else {
+          nextFiber = fiber.child;
+        }
+        dependency = dependency.next;
+      } while (dependency !== null);
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (nextFiber !== null) {
+      // Set the return pointer of the child to the work-in-progress fiber.
+      nextFiber.return = fiber;
+    } else {
+      // No child. Traverse to next sibling.
+      nextFiber = fiber;
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
+        var sibling = nextFiber.sibling;
+        if (sibling !== null) {
+          // Set the return pointer of the sibling to the work-in-progress fiber.
+          sibling.return = nextFiber.return;
+          nextFiber = sibling;
+          break;
+        }
+        // No more siblings. Traverse up.
+        nextFiber = nextFiber.return;
+      }
+    }
+    fiber = nextFiber;
+  }
 }
 
-function getContextChangedBits(context) {
-  return isPrimaryRenderer ? context._changedBits : context._changedBits2;
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastContextWithAllBitsObserved = null;
+
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (firstContextDependency !== null) {
+    // Reset the work-in-progress list
+    workInProgress.firstContextDependency = null;
+
+    // Iterate through the context dependencies and see if there were any
+    // changes. If so, continue propagating the context change by scanning
+    // the child subtree.
+    var dependency = firstContextDependency;
+    var hasPendingContext = false;
+    do {
+      var _context = dependency.context;
+      var changedBits = isPrimaryRenderer
+        ? _context._changedBits
+        : _context._changedBits2;
+      if (changedBits !== 0) {
+        // Resume context change propagation. We need to call this even if
+        // this fiber bails out, in case deeply nested consumers observe more
+        // bits than this one.
+        propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        );
+        if ((changedBits & dependency.observedBits) !== 0) {
+          hasPendingContext = true;
+        }
+      }
+      dependency = dependency.next;
+    } while (dependency !== null);
+    return hasPendingContext;
+  } else {
+    return false;
+  }
+}
+
+function readContext(context, observedBits) {
+  if (lastContextWithAllBitsObserved === context) {
+    // Nothing to do. We already observe everything in this context.
+  } else if (observedBits === false || observedBits === 0) {
+    // Do not observe any updates.
+  } else {
+    var resolvedObservedBits = void 0; // Avoid deopting on observable arguments or heterogeneous types.
+    if (
+      typeof observedBits !== "number" ||
+      observedBits === maxSigned31BitInt
+    ) {
+      // Observe all updates.
+      lastContextWithAllBitsObserved = context;
+      resolvedObservedBits = maxSigned31BitInt;
+    } else {
+      resolvedObservedBits = observedBits;
+    }
+
+    var contextItem = {
+      context: context,
+      observedBits: resolvedObservedBits,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      invariant(
+        currentlyRenderingFiber !== null,
+        "Context.unstable_read(): Context can only be read while React is " +
+          "rendering, e.g. inside the render method or getDerivedStateFromProps."
+      );
+      // This is the first dependency in the list
+      currentlyRenderingFiber.firstContextDependency = lastContextDependency = contextItem;
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+  return isPrimaryRenderer ? context._currentValue : context._currentValue2;
 }
 
 var NO_CONTEXT = {};
@@ -6656,6 +7030,7 @@ var fiberStack$1 = void 0;
   fiberStack$1 = [];
 }
 
+var syncCommitStartTime = 0;
 var timerPausedAt = 0;
 var totalElapsedPauseTime = 0;
 
@@ -6665,7 +7040,7 @@ function checkActualRenderTimeStackEmpty() {
   }
   {
     !(fiberStack$1.length === 0)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Expected an empty stack. Something was not reset properly."
         )
@@ -6692,6 +7067,14 @@ function pauseActualRenderTimerIfRunning() {
   if (timerPausedAt === 0) {
     timerPausedAt = now();
   }
+  if (syncCommitStartTime > 0) {
+    // Don't count the time spent processing sycn work,
+    // Against yielded async work that will be resumed later.
+    totalElapsedPauseTime += now() - syncCommitStartTime;
+    syncCommitStartTime = 0;
+  } else {
+    totalElapsedPauseTime = 0;
+  }
 }
 
 function recordElapsedActualRenderTime(fiber) {
@@ -6700,23 +7083,23 @@ function recordElapsedActualRenderTime(fiber) {
   }
   {
     !(fiber === fiberStack$1.pop())
-      ? warning(false, "Unexpected Fiber (%s) popped.", getComponentName(fiber))
+      ? warningWithoutStack$1(
+          false,
+          "Unexpected Fiber (%s) popped.",
+          getComponentName(fiber.type)
+        )
       : void 0;
   }
 
   fiber.actualDuration = now() - totalElapsedPauseTime - fiber.actualDuration;
 }
 
-function resetActualRenderTimer() {
+function resumeActualRenderTimerIfPaused(isProcessingSyncWork) {
   if (!enableProfilerTimer) {
     return;
   }
-  totalElapsedPauseTime = 0;
-}
-
-function resumeActualRenderTimerIfPaused() {
-  if (!enableProfilerTimer) {
-    return;
+  if (isProcessingSyncWork && syncCommitStartTime === 0) {
+    syncCommitStartTime = now();
   }
   if (timerPausedAt > 0) {
     totalElapsedPauseTime += now() - timerPausedAt;
@@ -6724,6 +7107,15 @@ function resumeActualRenderTimerIfPaused() {
   }
 }
 
+function resetActualRenderTimerStackAfterFatalErrorInDev() {
+  if (!enableProfilerTimer) {
+    return;
+  }
+  {
+    fiberStack$1.length = 0;
+  }
+}
+
 /**
  * The "base" render time is the duration of the “begin” phase of work for a particular fiber.
  * This time is measured and stored on each fiber.
@@ -6738,7 +7130,7 @@ function recordElapsedBaseRenderTimeIfRunning(fiber) {
     return;
   }
   if (baseStartTime !== -1) {
-    fiber.selfBaseTime = now() - baseStartTime;
+    fiber.selfBaseDuration = now() - baseStartTime;
   }
 }
 
@@ -6748,7 +7140,7 @@ function startBaseRenderTimer() {
   }
   {
     if (baseStartTime !== -1) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Cannot start base timer that is already running. " +
           "This error is likely caused by a bug in React. " +
@@ -6766,6 +7158,43 @@ function stopBaseRenderTimerIfRunning() {
   baseStartTime = -1;
 }
 
+/**
+ * Similar to invariant but only logs a warning if the condition is not met.
+ * This can be used to log issues in development environments in critical
+ * paths. Removing the logging code for production environments will keep the
+ * same logic and follow the same code paths.
+ */
+
+var warning = warningWithoutStack$1;
+
+{
+  warning = function(condition, format) {
+    if (condition) {
+      return;
+    }
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+    // eslint-disable-next-line react-internal/warning-and-invariant-args
+
+    for (
+      var _len = arguments.length,
+        args = Array(_len > 2 ? _len - 2 : 0),
+        _key = 2;
+      _key < _len;
+      _key++
+    ) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    warningWithoutStack$1.apply(
+      undefined,
+      [false, format + "%s"].concat(args, [stack])
+    );
+  };
+}
+
+var warning$1 = warning;
+
 /*eslint-disable no-self-compare */
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -6829,6 +7258,10 @@ function shallowEqual(objA, objB) {
 var fakeInternalInstance = {};
 var isArray = Array.isArray;
 
+// React.Component uses a shared frozen object by default.
+// We'll use it to determine whether we need to initialize legacy refs.
+var emptyRefsObject = new React.Component().refs;
+
 var didWarnAboutStateAssignmentForComponent = void 0;
 var didWarnAboutUninitializedState = void 0;
 var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
@@ -6853,7 +7286,7 @@ var warnOnInvalidCallback = void 0;
     var key = callerName + "_" + callback;
     if (!didWarnOnInvalidCallback.has(key)) {
       didWarnOnInvalidCallback.add(key);
-      warning(
+      warningWithoutStack$1(
         false,
         "%s(...): Expected the last optional `callback` argument to be a " +
           "function. Instead received: %s.",
@@ -6863,12 +7296,12 @@ var warnOnInvalidCallback = void 0;
     }
   };
 
-  warnOnUndefinedDerivedState = function(workInProgress, partialState) {
+  warnOnUndefinedDerivedState = function(type, partialState) {
     if (partialState === undefined) {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(type) || "Component";
       if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
         didWarnAboutUndefinedDerivedState.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
             "You have returned undefined.",
@@ -6921,7 +7354,7 @@ function applyDerivedStateFromProps(
   var partialState = getDerivedStateFromProps(nextProps, prevState);
 
   {
-    warnOnUndefinedDerivedState(workInProgress, partialState);
+    warnOnUndefinedDerivedState(workInProgress.type, partialState);
   }
   // Merge the partial state and the previous state.
   var memoizedState =
@@ -6933,7 +7366,7 @@ function applyDerivedStateFromProps(
   // Once the update queue is empty, persist the derived state onto the
   // base state.
   var updateQueue = workInProgress.updateQueue;
-  if (updateQueue !== null && updateQueue.expirationTime === NoWork) {
+  if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
     updateQueue.baseState = memoizedState;
   }
 }
@@ -6942,7 +7375,7 @@ var classComponentUpdater = {
   isMounted: isMounted,
   enqueueSetState: function(inst, payload, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -6954,12 +7387,12 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -6973,12 +7406,12 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -6991,7 +7424,7 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   }
 };
@@ -7002,7 +7435,7 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   var ctor = workInProgress.type;
@@ -7011,17 +7444,17 @@ function checkShouldComponentUpdate(
     var shouldUpdate = instance.shouldComponentUpdate(
       newProps,
       newState,
-      newContext
+      nextLegacyContext
     );
     stopPhaseTimer();
 
     {
       !(shouldUpdate !== undefined)
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s.shouldComponentUpdate(): Returned undefined instead of a " +
               "boolean value. Make sure to return true or false.",
-            getComponentName(workInProgress) || "Component"
+            getComponentName(ctor) || "Component"
           )
         : void 0;
     }
@@ -7042,19 +7475,19 @@ function checkClassInstance(workInProgress) {
   var instance = workInProgress.stateNode;
   var type = workInProgress.type;
   {
-    var name = getComponentName(workInProgress) || "Component";
+    var name = getComponentName(type) || "Component";
     var renderPresent = instance.render;
 
     if (!renderPresent) {
       if (type.prototype && typeof type.prototype.render === "function") {
-        warning(
+        warningWithoutStack$1(
           false,
           "%s(...): No `render` method found on the returned component " +
             "instance: did you accidentally return an object from the constructor?",
           name
         );
       } else {
-        warning(
+        warningWithoutStack$1(
           false,
           "%s(...): No `render` method found on the returned component " +
             "instance: you may have forgotten to define `render`.",
@@ -7068,7 +7501,7 @@ function checkClassInstance(workInProgress) {
       instance.getInitialState.isReactClassApproved ||
       instance.state;
     !noGetInitialStateOnES6
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "getInitialState was defined on %s, a plain JavaScript class. " +
             "This is only supported for classes created using React.createClass. " +
@@ -7080,7 +7513,7 @@ function checkClassInstance(workInProgress) {
       !instance.getDefaultProps ||
       instance.getDefaultProps.isReactClassApproved;
     !noGetDefaultPropsOnES6
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "getDefaultProps was defined on %s, a plain JavaScript class. " +
             "This is only supported for classes created using React.createClass. " +
@@ -7090,7 +7523,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstancePropTypes = !instance.propTypes;
     !noInstancePropTypes
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "propTypes was defined as an instance property on %s. Use a static " +
             "property to define propTypes instead.",
@@ -7099,7 +7532,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstanceContextTypes = !instance.contextTypes;
     !noInstanceContextTypes
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "contextTypes was defined as an instance property on %s. Use a static " +
             "property to define contextTypes instead.",
@@ -7109,7 +7542,7 @@ function checkClassInstance(workInProgress) {
     var noComponentShouldUpdate =
       typeof instance.componentShouldUpdate !== "function";
     !noComponentShouldUpdate
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
@@ -7123,18 +7556,18 @@ function checkClassInstance(workInProgress) {
       type.prototype.isPureReactComponent &&
       typeof instance.shouldComponentUpdate !== "undefined"
     ) {
-      warning(
+      warningWithoutStack$1(
         false,
         "%s has a method called shouldComponentUpdate(). " +
           "shouldComponentUpdate should not be used when extending React.PureComponent. " +
           "Please extend React.Component if shouldComponentUpdate is used.",
-        getComponentName(workInProgress) || "A pure component"
+        getComponentName(type) || "A pure component"
       );
     }
     var noComponentDidUnmount =
       typeof instance.componentDidUnmount !== "function";
     !noComponentDidUnmount
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentDidUnmount(). But there is no such lifecycle method. " +
@@ -7145,7 +7578,7 @@ function checkClassInstance(workInProgress) {
     var noComponentDidReceiveProps =
       typeof instance.componentDidReceiveProps !== "function";
     !noComponentDidReceiveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentDidReceiveProps(). But there is no such lifecycle method. " +
@@ -7158,7 +7591,7 @@ function checkClassInstance(workInProgress) {
     var noComponentWillRecieveProps =
       typeof instance.componentWillRecieveProps !== "function";
     !noComponentWillRecieveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
@@ -7168,7 +7601,7 @@ function checkClassInstance(workInProgress) {
     var noUnsafeComponentWillRecieveProps =
       typeof instance.UNSAFE_componentWillRecieveProps !== "function";
     !noUnsafeComponentWillRecieveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
@@ -7177,7 +7610,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var hasMutatedProps = instance.props !== workInProgress.pendingProps;
     !(instance.props === undefined || !hasMutatedProps)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s(...): When calling super() in `%s`, make sure to pass " +
             "up the same props that your component's constructor was passed.",
@@ -7187,7 +7620,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstanceDefaultProps = !instance.defaultProps;
     !noInstanceDefaultProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
             " Instead, define defaultProps as a static property on %s.",
@@ -7202,18 +7635,18 @@ function checkClassInstance(workInProgress) {
       !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(type)
     ) {
       didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type);
-      warning(
+      warningWithoutStack$1(
         false,
         "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
           "This component defines getSnapshotBeforeUpdate() only.",
-        getComponentName(workInProgress)
+        getComponentName(type)
       );
     }
 
     var noInstanceGetDerivedStateFromProps =
       typeof instance.getDerivedStateFromProps !== "function";
     !noInstanceGetDerivedStateFromProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getDerivedStateFromProps() is defined as an instance method " +
             "and will be ignored. Instead, declare it as a static method.",
@@ -7223,7 +7656,7 @@ function checkClassInstance(workInProgress) {
     var noInstanceGetDerivedStateFromCatch =
       typeof instance.getDerivedStateFromCatch !== "function";
     !noInstanceGetDerivedStateFromCatch
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getDerivedStateFromCatch() is defined as an instance method " +
             "and will be ignored. Instead, declare it as a static method.",
@@ -7233,7 +7666,7 @@ function checkClassInstance(workInProgress) {
     var noStaticGetSnapshotBeforeUpdate =
       typeof type.getSnapshotBeforeUpdate !== "function";
     !noStaticGetSnapshotBeforeUpdate
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getSnapshotBeforeUpdate() is defined as a static method " +
             "and will be ignored. Instead, declare it as an instance method.",
@@ -7242,11 +7675,15 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var _state = instance.state;
     if (_state && (typeof _state !== "object" || isArray(_state))) {
-      warning(false, "%s.state: must be set to an object or null", name);
+      warningWithoutStack$1(
+        false,
+        "%s.state: must be set to an object or null",
+        name
+      );
     }
     if (typeof instance.getChildContext === "function") {
       !(typeof type.childContextTypes === "object")
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s.getChildContext(): childContextTypes must be defined in order to " +
               "use getChildContext().",
@@ -7273,7 +7710,7 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
   var needsContext = isContextConsumer(workInProgress);
   var context = needsContext
     ? getMaskedContext(workInProgress, unmaskedContext)
-    : emptyObject;
+    : emptyContextObject;
 
   // Instantiate twice to help detect side-effects.
   {
@@ -7295,10 +7732,10 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
 
   {
     if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(ctor) || "Component";
       if (!didWarnAboutUninitializedState.has(componentName)) {
         didWarnAboutUninitializedState.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s: Did not properly initialize state during construction. " +
             "Expected state to be an object, but it was %s.",
@@ -7349,14 +7786,14 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
         foundWillReceivePropsName !== null ||
         foundWillUpdateName !== null
       ) {
-        var _componentName = getComponentName(workInProgress) || "Component";
+        var _componentName = getComponentName(ctor) || "Component";
         var newApiName =
           typeof ctor.getDerivedStateFromProps === "function"
             ? "getDerivedStateFromProps()"
             : "getSnapshotBeforeUpdate()";
         if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
           didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
-          warning(
+          warningWithoutStack$1(
             false,
             "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" +
               "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" +
@@ -7399,12 +7836,12 @@ function callComponentWillMount(workInProgress, instance) {
 
   if (oldState !== instance.state) {
     {
-      warning(
+      warningWithoutStack$1(
         false,
         "%s.componentWillMount(): Assigning directly to this.state is " +
           "deprecated (except inside a component's " +
           "constructor). Use setState instead.",
-        getComponentName(workInProgress) || "Component"
+        getComponentName(workInProgress.type) || "Component"
       );
     }
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
@@ -7415,24 +7852,24 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   var oldState = instance.state;
   startPhaseTimer(workInProgress, "componentWillReceiveProps");
   if (typeof instance.componentWillReceiveProps === "function") {
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   }
   if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   }
   stopPhaseTimer();
 
   if (instance.state !== oldState) {
     {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(workInProgress.type) || "Component";
       if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
         didWarnAboutStateAssignmentForComponent.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.componentWillReceiveProps(): Assigning directly to " +
             "this.state is deprecated (except inside a component's " +
@@ -7459,7 +7896,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
 
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
 
   {
@@ -7495,7 +7932,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     instance.state = workInProgress.memoizedState;
   }
 
-  var getDerivedStateFromProps = workInProgress.type.getDerivedStateFromProps;
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   if (typeof getDerivedStateFromProps === "function") {
     applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
     instance.state = workInProgress.memoizedState;
@@ -7530,7 +7967,11 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
   }
 }
 
-function resumeMountClassInstance(workInProgress, renderExpirationTime) {
+function resumeMountClassInstance(
+  workInProgress,
+  hasPendingNewContext,
+  renderExpirationTime
+) {
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
@@ -7539,8 +7980,11 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
   instance.props = oldProps;
 
   var oldContext = instance.context;
-  var newUnmaskedContext = getUnmaskedContext(workInProgress);
-  var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
+  var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress);
+  var nextLegacyContext = getMaskedContext(
+    workInProgress,
+    nextLegacyUnmaskedContext
+  );
 
   var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   var hasNewLifecycles =
@@ -7558,12 +8002,12 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
     (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
       typeof instance.componentWillReceiveProps === "function")
   ) {
-    if (oldProps !== newProps || oldContext !== newContext) {
+    if (oldProps !== newProps || oldContext !== nextLegacyContext) {
       callComponentWillReceiveProps(
         workInProgress,
         instance,
         newProps,
-        newContext
+        nextLegacyContext
       );
     }
   }
@@ -7587,6 +8031,7 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
     oldProps === newProps &&
     oldState === newState &&
     !hasContextChanged() &&
+    !hasPendingNewContext &&
     !checkHasForceUpdateAfterProcessing()
   ) {
     // If an update was already in progress, we should schedule an Update
@@ -7608,13 +8053,14 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
 
   var shouldUpdate =
     checkHasForceUpdateAfterProcessing() ||
+    hasPendingNewContext ||
     checkShouldComponentUpdate(
       workInProgress,
       oldProps,
       newProps,
       oldState,
       newState,
-      newContext
+      nextLegacyContext
     );
 
   if (shouldUpdate) {
@@ -7654,13 +8100,18 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
   // if shouldComponentUpdate returns false.
   instance.props = newProps;
   instance.state = newState;
-  instance.context = newContext;
+  instance.context = nextLegacyContext;
 
   return shouldUpdate;
 }
 
 // Invokes the update life-cycles and returns false if it shouldn't rerender.
-function updateClassInstance(current, workInProgress, renderExpirationTime) {
+function updateClassInstance(
+  current,
+  workInProgress,
+  hasPendingNewContext,
+  renderExpirationTime
+) {
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
@@ -7669,8 +8120,11 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
   instance.props = oldProps;
 
   var oldContext = instance.context;
-  var newUnmaskedContext = getUnmaskedContext(workInProgress);
-  var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
+  var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress);
+  var nextLegacyContext = getMaskedContext(
+    workInProgress,
+    nextLegacyUnmaskedContext
+  );
 
   var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   var hasNewLifecycles =
@@ -7688,12 +8142,12 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
       typeof instance.componentWillReceiveProps === "function")
   ) {
-    if (oldProps !== newProps || oldContext !== newContext) {
+    if (oldProps !== newProps || oldContext !== nextLegacyContext) {
       callComponentWillReceiveProps(
         workInProgress,
         instance,
         newProps,
-        newContext
+        nextLegacyContext
       );
     }
   }
@@ -7718,6 +8172,7 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     oldProps === newProps &&
     oldState === newState &&
     !hasContextChanged() &&
+    !hasPendingNewContext &&
     !checkHasForceUpdateAfterProcessing()
   ) {
     // If an update was already in progress, we should schedule an Update
@@ -7752,13 +8207,14 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
 
   var shouldUpdate =
     checkHasForceUpdateAfterProcessing() ||
+    hasPendingNewContext ||
     checkShouldComponentUpdate(
       workInProgress,
       oldProps,
       newProps,
       oldState,
       newState,
-      newContext
+      nextLegacyContext
     );
 
   if (shouldUpdate) {
@@ -7771,10 +8227,14 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     ) {
       startPhaseTimer(workInProgress, "componentWillUpdate");
       if (typeof instance.componentWillUpdate === "function") {
-        instance.componentWillUpdate(newProps, newState, newContext);
+        instance.componentWillUpdate(newProps, newState, nextLegacyContext);
       }
       if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        instance.UNSAFE_componentWillUpdate(newProps, newState, newContext);
+        instance.UNSAFE_componentWillUpdate(
+          newProps,
+          newState,
+          nextLegacyContext
+        );
       }
       stopPhaseTimer();
     }
@@ -7814,14 +8274,11 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
   // if shouldComponentUpdate returns false.
   instance.props = newProps;
   instance.state = newState;
-  instance.context = newContext;
+  instance.context = nextLegacyContext;
 
   return shouldUpdate;
 }
 
-var getCurrentFiberStackAddendum$2 =
-  ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
-
 var didWarnAboutMaps = void 0;
 var didWarnAboutStringRefInStrictMode = void 0;
 var ownerHasKeyUseWarning = void 0;
@@ -7858,25 +8315,24 @@ var warnForMissingKey = function(child) {};
       "Each child in an array or iterator should have a unique " +
       '"key" prop. See https://fb.me/react-warning-keys for ' +
       "more information." +
-      (getCurrentFiberStackAddendum$2() || "");
+      getCurrentFiberStackInDev();
     if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
       return;
     }
     ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
 
-    warning(
+    warning$1(
       false,
       "Each child in an array or iterator should have a unique " +
         '"key" prop. See https://fb.me/react-warning-keys for ' +
-        "more information.%s",
-      getCurrentFiberStackAddendum$2()
+        "more information."
     );
   };
 }
 
 var isArray$1 = Array.isArray;
 
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   var mixedRef = element.ref;
   if (
     mixedRef !== null &&
@@ -7885,9 +8341,9 @@ function coerceRef(returnFiber, current, element) {
   ) {
     {
       if (returnFiber.mode & StrictMode) {
-        var componentName = getComponentName(returnFiber) || "Component";
+        var componentName = getComponentName(returnFiber.type) || "Component";
         if (!didWarnAboutStringRefInStrictMode[componentName]) {
-          warning(
+          warningWithoutStack$1(
             false,
             'A string ref, "%s", has been found within a strict mode tree. ' +
               "String refs are a source of potential bugs and should be avoided. " +
@@ -7896,7 +8352,7 @@ function coerceRef(returnFiber, current, element) {
               "\n\nLearn more about using refs safely here:" +
               "\nhttps://fb.me/react-strict-mode-string-ref",
             mixedRef,
-            getStackAddendumByWorkInProgressFiber(returnFiber)
+            getStackByFiberInDevAndProd(returnFiber)
           );
           didWarnAboutStringRefInStrictMode[componentName] = true;
         }
@@ -7923,15 +8379,19 @@ function coerceRef(returnFiber, current, element) {
       var stringRef = "" + mixedRef;
       // Check if previous string ref matches new string ref
       if (
-        current !== null &&
-        current.ref !== null &&
-        typeof current.ref === "function" &&
-        current.ref._stringRef === stringRef
+        current$$1 !== null &&
+        current$$1.ref !== null &&
+        typeof current$$1.ref === "function" &&
+        current$$1.ref._stringRef === stringRef
       ) {
-        return current.ref;
+        return current$$1.ref;
       }
       var ref = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        var refs = inst.refs;
+        if (refs === emptyRefsObject) {
+          // This is a lazy pooled frozen object, so we need to initialize.
+          refs = inst.refs = {};
+        }
         if (value === null) {
           delete refs[stringRef];
         } else {
@@ -7967,7 +8427,7 @@ function throwOnInvalidObjectType(returnFiber, newChild) {
       addendum =
         " If you meant to render a collection of children, use an array " +
         "instead." +
-        (getCurrentFiberStackAddendum$2() || "");
+        getCurrentFiberStackInDev();
     }
     invariant(
       false,
@@ -7985,19 +8445,18 @@ function warnOnFunctionType() {
     "Functions are not valid as a React child. This may happen if " +
     "you return a Component instead of <Component /> from render. " +
     "Or maybe you meant to call this function rather than return it." +
-    (getCurrentFiberStackAddendum$2() || "");
+    getCurrentFiberStackInDev();
 
   if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
     return;
   }
   ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
 
-  warning(
+  warning$1(
     false,
     "Functions are not valid as a React child. This may happen if " +
       "you return a Component instead of <Component /> from render. " +
-      "Or maybe you meant to call this function rather than return it.%s",
-    getCurrentFiberStackAddendum$2() || ""
+      "Or maybe you meant to call this function rather than return it."
   );
 }
 
@@ -8075,9 +8534,9 @@ function ChildReconciler(shouldTrackSideEffects) {
       // Noop.
       return lastPlacedIndex;
     }
-    var current = newFiber.alternate;
-    if (current !== null) {
-      var oldIndex = current.index;
+    var current$$1 = newFiber.alternate;
+    if (current$$1 !== null) {
+      var oldIndex = current$$1.index;
       if (oldIndex < lastPlacedIndex) {
         // This is a move.
         newFiber.effectTag = Placement;
@@ -8102,8 +8561,13 @@ function ChildReconciler(shouldTrackSideEffects) {
     return newFiber;
   }
 
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (current === null || current.tag !== HostText) {
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (current$$1 === null || current$$1.tag !== HostText) {
       // Insert
       var created = createFiberFromText(
         textContent,
@@ -8114,17 +8578,17 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, textContent, expirationTime);
+      var existing = useFiber(current$$1, textContent, expirationTime);
       existing.return = returnFiber;
       return existing;
     }
   }
 
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (current !== null && current.type === element.type) {
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (current$$1 !== null && current$$1.type === element.type) {
       // Move based on index
-      var existing = useFiber(current, element.props, expirationTime);
-      existing.ref = coerceRef(returnFiber, current, element);
+      var existing = useFiber(current$$1, element.props, expirationTime);
+      existing.ref = coerceRef(returnFiber, current$$1, element);
       existing.return = returnFiber;
       {
         existing._debugSource = element._source;
@@ -8138,18 +8602,18 @@ function ChildReconciler(shouldTrackSideEffects) {
         returnFiber.mode,
         expirationTime
       );
-      created.ref = coerceRef(returnFiber, current, element);
+      created.ref = coerceRef(returnFiber, current$$1, element);
       created.return = returnFiber;
       return created;
     }
   }
 
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      current === null ||
-      current.tag !== HostPortal ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      current$$1 === null ||
+      current$$1.tag !== HostPortal ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     ) {
       // Insert
       var created = createFiberFromPortal(
@@ -8161,14 +8625,24 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, portal.children || [], expirationTime);
+      var existing = useFiber(
+        current$$1,
+        portal.children || [],
+        expirationTime
+      );
       existing.return = returnFiber;
       return existing;
     }
   }
 
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (current === null || current.tag !== Fragment) {
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (current$$1 === null || current$$1.tag !== Fragment) {
       // Insert
       var created = createFiberFromFragment(
         fragment,
@@ -8180,7 +8654,7 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, fragment, expirationTime);
+      var existing = useFiber(current$$1, fragment, expirationTime);
       existing.return = returnFiber;
       return existing;
     }
@@ -8433,15 +8907,14 @@ function ChildReconciler(shouldTrackSideEffects) {
             knownKeys.add(key);
             break;
           }
-          warning(
+          warning$1(
             false,
             "Encountered two children with the same key, `%s`. " +
               "Keys should be unique so that components maintain their identity " +
               "across updates. Non-unique keys may cause children to be " +
               "duplicated and/or omitted — the behavior is unsupported and " +
-              "could change in a future version.%s",
-            key,
-            getCurrentFiberStackAddendum$2()
+              "could change in a future version.",
+            key
           );
           break;
         default:
@@ -8632,12 +9105,11 @@ function ChildReconciler(shouldTrackSideEffects) {
       // Warn about using Maps as children
       if (newChildrenIterable.entries === iteratorFn) {
         !didWarnAboutMaps
-          ? warning(
+          ? warning$1(
               false,
               "Using Maps as children is unsupported and will likely yield " +
                 "unexpected results. Convert it to a sequence/iterable of keyed " +
-                "ReactElements instead.%s",
-              getCurrentFiberStackAddendum$2()
+                "ReactElements instead."
             )
           : void 0;
         didWarnAboutMaps = true;
@@ -9049,9 +9521,9 @@ function ChildReconciler(shouldTrackSideEffects) {
 var reconcileChildFibers = ChildReconciler(true);
 var mountChildFibers = ChildReconciler(false);
 
-function cloneChildFibers(current, workInProgress) {
+function cloneChildFibers(current$$1, workInProgress) {
   invariant(
-    current === null || workInProgress.child === current.child,
+    current$$1 === null || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
 
@@ -9397,8 +9869,7 @@ function resetHydrationState() {
   isHydrating = false;
 }
 
-var getCurrentFiberStackAddendum$1 =
-  ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
 
 var didWarnAboutBadClass = void 0;
 var didWarnAboutGetDerivedStateOnFunctionalComponent = void 0;
@@ -9410,23 +9881,13 @@ var didWarnAboutStatelessRefs = void 0;
   didWarnAboutStatelessRefs = {};
 }
 
-// TODO: Remove this and use reconcileChildrenAtExpirationTime directly.
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-
-function reconcileChildrenAtExpirationTime(
-  current,
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
-  if (current === null) {
+  if (current$$1 === null) {
     // If this is a fresh new component that hasn't been rendered yet, we
     // won't update its child set by applying minimal side-effects. Instead,
     // we will add them all to the child before it gets rendered. That means
@@ -9446,14 +9907,14 @@ function reconcileChildrenAtExpirationTime(
     // let's throw it out.
     workInProgress.child = reconcileChildFibers(
       workInProgress,
-      current.child,
+      current$$1.child,
       nextChildren,
       renderExpirationTime
     );
   }
 }
 
-function updateForwardRef(current, workInProgress) {
+function updateForwardRef(current$$1, workInProgress, renderExpirationTime) {
   var render = workInProgress.type.render;
   var nextProps = workInProgress.pendingProps;
   var ref = workInProgress.ref;
@@ -9461,119 +9922,132 @@ function updateForwardRef(current, workInProgress) {
     // Normally we can bail out on props equality but if context has changed
     // we don't do the bailout and we have to reuse existing props instead.
   } else if (workInProgress.memoizedProps === nextProps) {
-    var currentRef = current !== null ? current.ref : null;
+    var currentRef = current$$1 !== null ? current$$1.ref : null;
     if (ref === currentRef) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
+      return bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     }
   }
 
   var nextChildren = void 0;
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     nextChildren = render(nextProps, ref);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
 
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateFragment(current, workInProgress) {
+function updateFragment(current$$1, workInProgress, renderExpirationTime) {
   var nextChildren = workInProgress.pendingProps;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (workInProgress.memoizedProps === nextChildren) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextChildren);
   return workInProgress.child;
 }
 
-function updateMode(current, workInProgress) {
+function updateMode(current$$1, workInProgress, renderExpirationTime) {
   var nextChildren = workInProgress.pendingProps.children;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (
-    nextChildren === null ||
-    workInProgress.memoizedProps === nextChildren
-  ) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextChildren);
   return workInProgress.child;
 }
 
-function updateProfiler(current, workInProgress) {
-  var nextProps = workInProgress.pendingProps;
+function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
   if (enableProfilerTimer) {
     workInProgress.effectTag |= Update;
   }
-  if (workInProgress.memoizedProps === nextProps) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
+  var nextProps = workInProgress.pendingProps;
   var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (current === null && ref !== null) ||
-    (current !== null && current.ref !== ref)
+    (current$$1 === null && ref !== null) ||
+    (current$$1 !== null && current$$1.ref !== ref)
   ) {
     // Schedule a Ref effect
     workInProgress.effectTag |= Ref;
   }
 }
 
-function updateFunctionalComponent(current, workInProgress) {
+function updateFunctionalComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   var fn = workInProgress.type;
   var nextProps = workInProgress.pendingProps;
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else {
-    if (workInProgress.memoizedProps === nextProps) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    // TODO: consider bringing fn.shouldComponentUpdate() back.
-    // It used to be here.
-  }
-
   var unmaskedContext = getUnmaskedContext(workInProgress);
   var context = getMaskedContext(workInProgress, unmaskedContext);
 
   var nextChildren = void 0;
-
+  prepareToReadContext(workInProgress, renderExpirationTime);
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     nextChildren = fn(nextProps, context);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
+
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateClassComponent(current, workInProgress, renderExpirationTime) {
+function updateClassComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   // Push context providers early to prevent context stack mismatches.
   // During mounting we don't know the child context yet as the instance doesn't exist.
   // We will invalidate the child context in finishClassComponent() right after rendering.
   var hasContext = pushContextProvider(workInProgress);
+  var hasPendingNewContext = prepareToReadContext(
+    workInProgress,
+    renderExpirationTime
+  );
+
   var shouldUpdate = void 0;
-  if (current === null) {
+  if (current$$1 === null) {
     if (workInProgress.stateNode === null) {
       // In the initial pass we might need to construct the instance.
       constructClassInstance(
@@ -9588,18 +10062,20 @@ function updateClassComponent(current, workInProgress, renderExpirationTime) {
       // In a resume, we'll already have an instance we can reuse.
       shouldUpdate = resumeMountClassInstance(
         workInProgress,
+        hasPendingNewContext,
         renderExpirationTime
       );
     }
   } else {
     shouldUpdate = updateClassInstance(
-      current,
+      current$$1,
       workInProgress,
+      hasPendingNewContext,
       renderExpirationTime
     );
   }
   return finishClassComponent(
-    current,
+    current$$1,
     workInProgress,
     shouldUpdate,
     hasContext,
@@ -9608,14 +10084,14 @@ function updateClassComponent(current, workInProgress, renderExpirationTime) {
 }
 
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
   // Refs should update even if shouldComponentUpdate returns false
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
 
   var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
 
@@ -9625,14 +10101,18 @@ function finishClassComponent(
       invalidateContextProvider(workInProgress, false);
     }
 
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
 
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
   // Rerender
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   var nextChildren = void 0;
   if (
     didCaptureError &&
@@ -9651,7 +10131,7 @@ function finishClassComponent(
     }
   } else {
     {
-      ReactDebugCurrentFiber.setCurrentPhase("render");
+      setCurrentPhase("render");
       nextChildren = instance.render();
       if (
         debugRenderPhaseSideEffects ||
@@ -9660,28 +10140,23 @@ function finishClassComponent(
       ) {
         instance.render();
       }
-      ReactDebugCurrentFiber.setCurrentPhase(null);
+      setCurrentPhase(null);
     }
   }
 
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  if (didCaptureError) {
+  if (current$$1 !== null && didCaptureError) {
     // If we're recovering from an error, reconcile twice: first to delete
     // all the existing children.
-    reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    );
+    reconcileChildren(current$$1, workInProgress, null, renderExpirationTime);
     workInProgress.child = null;
     // Now we can continue reconciling like normal. This has the effect of
     // remounting all children regardless of whether their their
     // identity matches.
   }
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -9714,99 +10189,89 @@ function pushHostRootContext(workInProgress) {
   pushHostContainer(workInProgress, root.containerInfo);
 }
 
-function updateHostRoot(current, workInProgress, renderExpirationTime) {
+function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
   pushHostRootContext(workInProgress);
   var updateQueue = workInProgress.updateQueue;
-  if (updateQueue !== null) {
-    var nextProps = workInProgress.pendingProps;
-    var prevState = workInProgress.memoizedState;
-    var prevChildren = prevState !== null ? prevState.element : null;
-    processUpdateQueue(
+  invariant(
+    updateQueue !== null,
+    "If the root does not have an updateQueue, we should have already " +
+      "bailed out. This error is likely caused by a bug in React. Please " +
+      "file an issue."
+  );
+  var nextProps = workInProgress.pendingProps;
+  var prevState = workInProgress.memoizedState;
+  var prevChildren = prevState !== null ? prevState.element : null;
+  processUpdateQueue(
+    workInProgress,
+    updateQueue,
+    nextProps,
+    null,
+    renderExpirationTime
+  );
+  var nextState = workInProgress.memoizedState;
+  // Caution: React DevTools currently depends on this property
+  // being called "element".
+  var nextChildren = nextState.element;
+  if (nextChildren === prevChildren) {
+    // If the state is the same as before, that's a bailout because we had
+    // no work that expires at this time.
+    resetHydrationState();
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
       workInProgress,
-      updateQueue,
-      nextProps,
-      null,
       renderExpirationTime
     );
-    var nextState = workInProgress.memoizedState;
-    // Caution: React DevTools currently depends on this property
-    // being called "element".
-    var nextChildren = nextState.element;
-
-    if (nextChildren === prevChildren) {
-      // If the state is the same as before, that's a bailout because we had
-      // no work that expires at this time.
-      resetHydrationState();
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    var root = workInProgress.stateNode;
-    if (
-      (current === null || current.child === null) &&
-      root.hydrate &&
-      enterHydrationState(workInProgress)
-    ) {
-      // If we don't have any current children this might be the first pass.
-      // We always try to hydrate. If this isn't a hydration pass there won't
-      // be any children to hydrate which is effectively the same thing as
-      // not hydrating.
-
-      // This is a bit of a hack. We track the host root as a placement to
-      // know that we're currently in a mounting state. That way isMounted
-      // works as expected. We must reset this before committing.
-      // TODO: Delete this when we delete isMounted and findDOMNode.
-      workInProgress.effectTag |= Placement;
-
-      // Ensure that children mount into this root without tracking
-      // side-effects. This ensures that we don't store Placement effects on
-      // nodes that will be hydrated.
-      workInProgress.child = mountChildFibers(
-        workInProgress,
-        null,
-        nextChildren,
-        renderExpirationTime
-      );
-    } else {
-      // Otherwise reset hydration state in case we aborted and resumed another
-      // root.
-      resetHydrationState();
-      reconcileChildren(current, workInProgress, nextChildren);
-    }
-    return workInProgress.child;
   }
-  resetHydrationState();
-  // If there is no update queue, that's a bailout because the root has no props.
-  return bailoutOnAlreadyFinishedWork(current, workInProgress);
+  var root = workInProgress.stateNode;
+  if (
+    (current$$1 === null || current$$1.child === null) &&
+    root.hydrate &&
+    enterHydrationState(workInProgress)
+  ) {
+    // If we don't have any current children this might be the first pass.
+    // We always try to hydrate. If this isn't a hydration pass there won't
+    // be any children to hydrate which is effectively the same thing as
+    // not hydrating.
+
+    // This is a bit of a hack. We track the host root as a placement to
+    // know that we're currently in a mounting state. That way isMounted
+    // works as expected. We must reset this before committing.
+    // TODO: Delete this when we delete isMounted and findDOMNode.
+    workInProgress.effectTag |= Placement;
+
+    // Ensure that children mount into this root without tracking
+    // side-effects. This ensures that we don't store Placement effects on
+    // nodes that will be hydrated.
+    workInProgress.child = mountChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderExpirationTime
+    );
+  } else {
+    // Otherwise reset hydration state in case we aborted and resumed another
+    // root.
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
+    resetHydrationState();
+  }
+  return workInProgress.child;
 }
 
-function updateHostComponent(current, workInProgress, renderExpirationTime) {
+function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
   pushHostContext(workInProgress);
 
-  if (current === null) {
+  if (current$$1 === null) {
     tryToClaimNextHydratableInstance(workInProgress);
   }
 
   var type = workInProgress.type;
-  var memoizedProps = workInProgress.memoizedProps;
   var nextProps = workInProgress.pendingProps;
-  var prevProps = current !== null ? current.memoizedProps : null;
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (memoizedProps === nextProps) {
-    var isHidden =
-      workInProgress.mode & AsyncMode &&
-      shouldDeprioritizeSubtree(type, nextProps);
-    if (isHidden) {
-      // Before bailing out, make sure we've deprioritized a hidden component.
-      workInProgress.expirationTime = Never;
-    }
-    if (!isHidden || renderExpirationTime !== Never) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    // If we're rendering a hidden node at hidden priority, don't bailout. The
-    // parent is complete, but the children may not be.
-  }
+  var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
 
   var nextChildren = nextProps.children;
   var isDirectTextChild = shouldSetTextContent(type, nextProps);
@@ -9817,13 +10282,13 @@ function updateHostComponent(current, workInProgress, renderExpirationTime) {
     // this in the host environment that also have access to this prop. That
     // avoids allocating another HostText fiber and traversing it.
     nextChildren = null;
-  } else if (prevProps && shouldSetTextContent(type, prevProps)) {
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
     // If we're switching from a direct text child to a normal child, or to
     // empty, we need to schedule the text content to be reset.
     workInProgress.effectTag |= ContentReset;
   }
 
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
 
   // Check the host config to see if the children are offscreen/hidden.
   if (
@@ -9831,20 +10296,24 @@ function updateHostComponent(current, workInProgress, renderExpirationTime) {
     workInProgress.mode & AsyncMode &&
     shouldDeprioritizeSubtree(type, nextProps)
   ) {
-    // Down-prioritize the children.
+    // Schedule this fiber to re-render at offscreen priority. Then bailout.
     workInProgress.expirationTime = Never;
-    // Bailout and come back to this fiber later.
     workInProgress.memoizedProps = nextProps;
     return null;
   }
 
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateHostText(current, workInProgress) {
-  if (current === null) {
+function updateHostText(current$$1, workInProgress) {
+  if (current$$1 === null) {
     tryToClaimNextHydratableInstance(workInProgress);
   }
   var nextProps = workInProgress.pendingProps;
@@ -9855,12 +10324,12 @@ function updateHostText(current, workInProgress) {
 }
 
 function mountIndeterminateComponent(
-  current,
+  current$$1,
   workInProgress,
   renderExpirationTime
 ) {
   invariant(
-    current === null,
+    current$$1 === null,
     "An indeterminate component should never have mounted. This error is " +
       "likely caused by a bug in React. Please file an issue."
   );
@@ -9869,14 +10338,16 @@ function mountIndeterminateComponent(
   var unmaskedContext = getUnmaskedContext(workInProgress);
   var context = getMaskedContext(workInProgress, unmaskedContext);
 
+  prepareToReadContext(workInProgress, renderExpirationTime);
+
   var value = void 0;
 
   {
     if (fn.prototype && typeof fn.prototype.render === "function") {
-      var componentName = getComponentName(workInProgress) || "Unknown";
+      var componentName = getComponentName(fn) || "Unknown";
 
       if (!didWarnAboutBadClass[componentName]) {
-        warning(
+        warningWithoutStack$1(
           false,
           "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
             "This is likely to cause errors. Change %s to extend React.Component instead.",
@@ -9891,7 +10362,7 @@ function mountIndeterminateComponent(
       ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
     }
 
-    ReactCurrentOwner.current = workInProgress;
+    ReactCurrentOwner$3.current = workInProgress;
     value = fn(props, context);
   }
   // React DevTools reads this flag.
@@ -9927,7 +10398,7 @@ function mountIndeterminateComponent(
     adoptClassInstance(workInProgress, value);
     mountClassInstance(workInProgress, renderExpirationTime);
     return finishClassComponent(
-      current,
+      current$$1,
       workInProgress,
       true,
       hasContext,
@@ -9941,7 +10412,7 @@ function mountIndeterminateComponent(
 
       if (_Component) {
         !!_Component.childContextTypes
-          ? warning(
+          ? warningWithoutStack$1(
               false,
               "%s(...): childContextTypes cannot be defined on a functional component.",
               _Component.displayName || _Component.name || "Component"
@@ -9950,7 +10421,7 @@ function mountIndeterminateComponent(
       }
       if (workInProgress.ref !== null) {
         var info = "";
-        var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName();
+        var ownerName = getCurrentFiberOwnerNameInDevOrNull();
         if (ownerName) {
           info += "\n\nCheck the render method of `" + ownerName + "`.";
         }
@@ -9962,21 +10433,20 @@ function mountIndeterminateComponent(
         }
         if (!didWarnAboutStatelessRefs[warningKey]) {
           didWarnAboutStatelessRefs[warningKey] = true;
-          warning(
+          warning$1(
             false,
             "Stateless function components cannot be given refs. " +
-              "Attempts to access this ref will fail.%s%s",
-            info,
-            ReactDebugCurrentFiber.getCurrentFiberStackAddendum()
+              "Attempts to access this ref will fail.%s",
+            info
           );
         }
       }
 
       if (typeof fn.getDerivedStateFromProps === "function") {
-        var _componentName = getComponentName(workInProgress) || "Unknown";
+        var _componentName = getComponentName(fn) || "Unknown";
 
         if (!didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName]) {
-          warning(
+          warningWithoutStack$1(
             false,
             "%s: Stateless functional components do not support getDerivedStateFromProps.",
             _componentName
@@ -9987,53 +10457,85 @@ function mountIndeterminateComponent(
         }
       }
     }
-    reconcileChildren(current, workInProgress, value);
+    reconcileChildren(current$$1, workInProgress, value, renderExpirationTime);
     memoizeProps(workInProgress, props);
     return workInProgress.child;
   }
 }
 
-function updateTimeoutComponent(current, workInProgress, renderExpirationTime) {
+function updatePlaceholderComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   if (enableSuspense) {
     var nextProps = workInProgress.pendingProps;
-    var prevProps = workInProgress.memoizedProps;
-
-    var prevDidTimeout = workInProgress.memoizedState;
 
     // Check if we already attempted to render the normal state. If we did,
     // and we timed out, render the placeholder state.
     var alreadyCaptured = (workInProgress.effectTag & DidCapture) === NoEffect;
-    var nextDidTimeout = !alreadyCaptured;
 
-    if (hasContextChanged()) {
-      // Normally we can bail out on props equality but if context has changed
-      // we don't do the bailout and we have to reuse existing props instead.
-    } else if (nextProps === prevProps && nextDidTimeout === prevDidTimeout) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
+    var nextDidTimeout = void 0;
+    if (current$$1 !== null && workInProgress.updateQueue !== null) {
+      // We're outside strict mode. Something inside this Placeholder boundary
+      // suspended during the last commit. Switch to the placholder.
+      workInProgress.updateQueue = null;
+      nextDidTimeout = true;
+      // If we're recovering from an error, reconcile twice: first to delete
+      // all the existing children.
+      reconcileChildren(current$$1, workInProgress, null, renderExpirationTime);
+      current$$1.child = null;
+      // Now we can continue reconciling like normal. This has the effect of
+      // remounting all children regardless of whether their their
+      // identity matches.
+    } else {
+      nextDidTimeout = !alreadyCaptured;
+    }
+
+    if ((workInProgress.mode & StrictMode) !== NoEffect) {
+      if (nextDidTimeout) {
+        // If the timed-out view commits, schedule an update effect to record
+        // the committed time.
+        workInProgress.effectTag |= Update;
+      } else {
+        // The state node points to the time at which placeholder timed out.
+        // We can clear it once we switch back to the normal children.
+        workInProgress.stateNode = null;
+      }
+    }
+
+    // If the `children` prop is a function, treat it like a render prop.
+    // TODO: This is temporary until we finalize a lower level API.
+    var children = nextProps.children;
+    var nextChildren = void 0;
+    if (typeof children === "function") {
+      nextChildren = children(nextDidTimeout);
+    } else {
+      nextChildren = nextDidTimeout ? nextProps.fallback : children;
     }
 
-    var render = nextProps.children;
-    var nextChildren = render(nextDidTimeout);
     workInProgress.memoizedProps = nextProps;
     workInProgress.memoizedState = nextDidTimeout;
-    reconcileChildren(current, workInProgress, nextChildren);
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
     return workInProgress.child;
   } else {
     return null;
   }
 }
 
-function updatePortalComponent(current, workInProgress, renderExpirationTime) {
+function updatePortalComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
   var nextChildren = workInProgress.pendingProps;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (workInProgress.memoizedProps === nextChildren) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-
-  if (current === null) {
+  if (current$$1 === null) {
     // Portals are special because we don't append the children during mount
     // but at commit. Therefore we need to track insertions which the normal
     // flow doesn't do during mount. This doesn't happen at the root because
@@ -10047,123 +10549,27 @@ function updatePortalComponent(current, workInProgress, renderExpirationTime) {
     );
     memoizeProps(workInProgress, nextChildren);
   } else {
-    reconcileChildren(current, workInProgress, nextChildren);
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
     memoizeProps(workInProgress, nextChildren);
   }
   return workInProgress.child;
 }
 
-function propagateContextChange(
+function updateContextProvider(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
-  }
-  while (fiber !== null) {
-    var nextFiber = void 0;
-    // Visit this fiber.
-    switch (fiber.tag) {
-      case ContextConsumer:
-        // Check if the context matches.
-        var observedBits = fiber.stateNode | 0;
-        if (fiber.type === context && (observedBits & changedBits) !== 0) {
-          // Update the expiration time of all the ancestors, including
-          // the alternates.
-          var node = fiber;
-          while (node !== null) {
-            var alternate = node.alternate;
-            if (
-              node.expirationTime === NoWork ||
-              node.expirationTime > renderExpirationTime
-            ) {
-              node.expirationTime = renderExpirationTime;
-              if (
-                alternate !== null &&
-                (alternate.expirationTime === NoWork ||
-                  alternate.expirationTime > renderExpirationTime)
-              ) {
-                alternate.expirationTime = renderExpirationTime;
-              }
-            } else if (
-              alternate !== null &&
-              (alternate.expirationTime === NoWork ||
-                alternate.expirationTime > renderExpirationTime)
-            ) {
-              alternate.expirationTime = renderExpirationTime;
-            } else {
-              // Neither alternate was updated, which means the rest of the
-              // ancestor path already has sufficient priority.
-              break;
-            }
-            node = node.return;
-          }
-          // Don't scan deeper than a matching consumer. When we render the
-          // consumer, we'll continue scanning from that point. This way the
-          // scanning work is time-sliced.
-          nextFiber = null;
-        } else {
-          // Traverse down.
-          nextFiber = fiber.child;
-        }
-        break;
-      case ContextProvider:
-        // Don't scan deeper if this is a matching provider
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        // Traverse down.
-        nextFiber = fiber.child;
-        break;
-    }
-    if (nextFiber !== null) {
-      // Set the return pointer of the child to the work-in-progress fiber.
-      nextFiber.return = fiber;
-    } else {
-      // No child. Traverse to next sibling.
-      nextFiber = fiber;
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
-        }
-        var sibling = nextFiber.sibling;
-        if (sibling !== null) {
-          // Set the return pointer of the sibling to the work-in-progress fiber.
-          sibling.return = nextFiber.return;
-          nextFiber = sibling;
-          break;
-        }
-        // No more siblings. Traverse up.
-        nextFiber = nextFiber.return;
-      }
-    }
-    fiber = nextFiber;
-  }
-}
-
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
   var providerType = workInProgress.type;
   var context = providerType._context;
 
   var newProps = workInProgress.pendingProps;
   var oldProps = workInProgress.memoizedProps;
-  var canBailOnProps = true;
-
-  if (hasContextChanged()) {
-    canBailOnProps = false;
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (oldProps === newProps) {
-    workInProgress.stateNode = 0;
-    pushProvider(workInProgress);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
 
   var newValue = newProps.value;
   workInProgress.memoizedProps = newProps;
@@ -10177,7 +10583,7 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
         newProps,
         "prop",
         "Context.Provider",
-        getCurrentFiberStackAddendum$1
+        getCurrentFiberStackInDev
       );
     }
   }
@@ -10185,14 +10591,18 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
   var changedBits = void 0;
   if (oldProps === null) {
     // Initial render
-    changedBits = MAX_SIGNED_31_BIT_INT;
+    changedBits = maxSigned31BitInt;
   } else {
     if (oldProps.value === newProps.value) {
       // No change. Bailout early if children are the same.
-      if (oldProps.children === newProps.children && canBailOnProps) {
+      if (oldProps.children === newProps.children && !hasContextChanged()) {
         workInProgress.stateNode = 0;
         pushProvider(workInProgress);
-        return bailoutOnAlreadyFinishedWork(current, workInProgress);
+        return bailoutOnAlreadyFinishedWork(
+          current$$1,
+          workInProgress,
+          renderExpirationTime
+        );
       }
       changedBits = 0;
     } else {
@@ -10206,20 +10616,24 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
         (oldValue !== oldValue && newValue !== newValue) // eslint-disable-line no-self-compare
       ) {
         // No change. Bailout early if children are the same.
-        if (oldProps.children === newProps.children && canBailOnProps) {
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
           workInProgress.stateNode = 0;
           pushProvider(workInProgress);
-          return bailoutOnAlreadyFinishedWork(current, workInProgress);
+          return bailoutOnAlreadyFinishedWork(
+            current$$1,
+            workInProgress,
+            renderExpirationTime
+          );
         }
         changedBits = 0;
       } else {
         changedBits =
           typeof context._calculateChangedBits === "function"
             ? context._calculateChangedBits(oldValue, newValue)
-            : MAX_SIGNED_31_BIT_INT;
+            : maxSigned31BitInt;
         {
-          !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits)
-            ? warning(
+          !((changedBits & maxSigned31BitInt) === changedBits)
+            ? warning$1(
                 false,
                 "calculateChangedBits: Expected the return value to be a " +
                   "31-bit integer. Instead received: %s",
@@ -10231,10 +10645,14 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
 
         if (changedBits === 0) {
           // No change. Bailout early if children are the same.
-          if (oldProps.children === newProps.children && canBailOnProps) {
+          if (oldProps.children === newProps.children && !hasContextChanged()) {
             workInProgress.stateNode = 0;
             pushProvider(workInProgress);
-            return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            return bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
           }
         } else {
           propagateContextChange(
@@ -10252,57 +10670,27 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
   pushProvider(workInProgress);
 
   var newChildren = newProps.children;
-  reconcileChildren(current, workInProgress, newChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    newChildren,
+    renderExpirationTime
+  );
   return workInProgress.child;
 }
 
-function updateContextConsumer(current, workInProgress, renderExpirationTime) {
+function updateContextConsumer(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   var context = workInProgress.type;
   var newProps = workInProgress.pendingProps;
-  var oldProps = workInProgress.memoizedProps;
-
-  var newValue = getContextCurrentValue(context);
-  var changedBits = getContextChangedBits(context);
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (changedBits === 0 && oldProps === newProps) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  workInProgress.memoizedProps = newProps;
-
-  var observedBits = newProps.unstable_observedBits;
-  if (observedBits === undefined || observedBits === null) {
-    // Subscribe to all changes by default
-    observedBits = MAX_SIGNED_31_BIT_INT;
-  }
-  // Store the observedBits on the fiber's stateNode for quick access.
-  workInProgress.stateNode = observedBits;
-
-  if ((changedBits & observedBits) !== 0) {
-    // Context change propagation stops at matching consumers, for time-
-    // slicing. Continue the propagation here.
-    propagateContextChange(
-      workInProgress,
-      context,
-      changedBits,
-      renderExpirationTime
-    );
-  } else if (oldProps === newProps) {
-    // Skip over a memoized parent with a bitmask bailout even
-    // if we began working on it because of a deeper matching child.
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  // There is no bailout on `children` equality because we expect people
-  // to often pass a bound method as a child, but it may reference
-  // `this.state` or `this.props` (and thus needs to re-render on `setState`).
-
   var render = newProps.children;
 
   {
     !(typeof render === "function")
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "A context consumer was rendered with multiple children, or a child " +
             "that isn't a function. A context consumer expects a single child " +
@@ -10312,17 +10700,25 @@ function updateContextConsumer(current, workInProgress, renderExpirationTime) {
       : void 0;
   }
 
+  prepareToReadContext(workInProgress, renderExpirationTime);
+  var newValue = readContext(context, newProps.unstable_observedBits);
   var newChildren = void 0;
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     newChildren = render(newValue);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
 
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  reconcileChildren(current, workInProgress, newChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    newChildren,
+    renderExpirationTime
+  );
+  workInProgress.memoizedProps = newProps;
   return workInProgress.child;
 }
 
@@ -10345,59 +10741,39 @@ function updateContextConsumer(current, workInProgress, renderExpirationTime) {
   }
   */
 
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   cancelWorkTimer(workInProgress);
 
+  if (current$$1 !== null) {
+    // Reuse previous context list
+    workInProgress.firstContextDependency = current$$1.firstContextDependency;
+  }
+
   if (enableProfilerTimer) {
     // Don't update "base" render times for bailouts.
     stopBaseRenderTimerIfRunning();
   }
 
-  // TODO: We should ideally be able to bail out early if the children have no
-  // more work to do. However, since we don't have a separation of this
-  // Fiber's priority and its children yet - we don't know without doing lots
-  // of the same work we do anyway. Once we have that separation we can just
-  // bail out here if the children has no more work at this priority level.
-  // if (workInProgress.priorityOfChildren <= priorityLevel) {
-  //   // If there are side-effects in these children that have not yet been
-  //   // committed we need to ensure that they get properly transferred up.
-  //   if (current && current.child !== workInProgress.child) {
-  //     reuseChildrenEffects(workInProgress, child);
-  //   }
-  //   return null;
-  // }
-
-  cloneChildFibers(current, workInProgress);
-  return workInProgress.child;
-}
-
-function bailoutOnLowPriority(current, workInProgress) {
-  cancelWorkTimer(workInProgress);
-
-  if (enableProfilerTimer) {
-    // Don't update "base" render times for bailouts.
-    stopBaseRenderTimerIfRunning();
+  // Check if the children have any pending work.
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (
+    childExpirationTime === NoWork ||
+    childExpirationTime > renderExpirationTime
+  ) {
+    // The children don't have any work either. We can skip them.
+    // TODO: Once we add back resuming, we should check if the children are
+    // a work-in-progress set. If so, we need to transfer their effects.
+    return null;
+  } else {
+    // This fiber doesn't have work, but its subtree does. Clone the child
+    // fibers and continue.
+    cloneChildFibers(current$$1, workInProgress);
+    return workInProgress.child;
   }
-
-  // TODO: Handle HostComponent tags here as well and call pushHostContext()?
-  // See PR 8590 discussion for context
-  switch (workInProgress.tag) {
-    case HostRoot:
-      pushHostRootContext(workInProgress);
-      break;
-    case ClassComponent:
-      pushContextProvider(workInProgress);
-      break;
-    case HostPortal:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
-    case ContextProvider:
-      pushProvider(workInProgress);
-      break;
-  }
-  // TODO: What if this is currently in progress?
-  // How can that happen? How is this not being cloned?
-  return null;
 }
 
 // TODO: Delete memoizeProps/State and move to reconcile/bailout instead
@@ -10411,70 +10787,117 @@ function memoizeState(workInProgress, nextState) {
   // is handled by processUpdateQueue.
 }
 
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
   if (enableProfilerTimer) {
     if (workInProgress.mode & ProfileMode) {
       markActualRenderTimeStarted(workInProgress);
     }
   }
 
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    workInProgress.expirationTime === NoWork ||
-    workInProgress.expirationTime > renderExpirationTime
+    !hasContextChanged() &&
+    (updateExpirationTime === NoWork ||
+      updateExpirationTime > renderExpirationTime)
   ) {
-    return bailoutOnLowPriority(current, workInProgress);
+    // This fiber does not have any pending work. Bailout without entering
+    // the begin phase. There's still some bookkeeping we that needs to be done
+    // in this optimized path, mostly pushing stuff onto the stack.
+    switch (workInProgress.tag) {
+      case HostRoot:
+        pushHostRootContext(workInProgress);
+        resetHydrationState();
+        break;
+      case HostComponent:
+        pushHostContext(workInProgress);
+        break;
+      case ClassComponent:
+        pushContextProvider(workInProgress);
+        break;
+      case HostPortal:
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        );
+        break;
+      case ContextProvider:
+        workInProgress.stateNode = 0;
+        pushProvider(workInProgress);
+        break;
+      case Profiler:
+        if (enableProfilerTimer) {
+          workInProgress.effectTag |= Update;
+        }
+        break;
+    }
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
 
+  // Before entering the begin phase, clear the expiration time.
+  workInProgress.expirationTime = NoWork;
+
   switch (workInProgress.tag) {
     case IndeterminateComponent:
       return mountIndeterminateComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case FunctionalComponent:
-      return updateFunctionalComponent(current, workInProgress);
+      return updateFunctionalComponent(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     case ClassComponent:
       return updateClassComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case HostRoot:
-      return updateHostRoot(current, workInProgress, renderExpirationTime);
+      return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
     case HostComponent:
-      return updateHostComponent(current, workInProgress, renderExpirationTime);
+      return updateHostComponent(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     case HostText:
-      return updateHostText(current, workInProgress);
-    case TimeoutComponent:
-      return updateTimeoutComponent(
-        current,
+      return updateHostText(current$$1, workInProgress);
+    case PlaceholderComponent:
+      return updatePlaceholderComponent(
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case HostPortal:
       return updatePortalComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case ForwardRef:
-      return updateForwardRef(current, workInProgress);
+      return updateForwardRef(current$$1, workInProgress, renderExpirationTime);
     case Fragment:
-      return updateFragment(current, workInProgress);
+      return updateFragment(current$$1, workInProgress, renderExpirationTime);
     case Mode:
-      return updateMode(current, workInProgress);
+      return updateMode(current$$1, workInProgress, renderExpirationTime);
     case Profiler:
-      return updateProfiler(current, workInProgress);
+      return updateProfiler(current$$1, workInProgress, renderExpirationTime);
     case ContextProvider:
       return updateContextProvider(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case ContextConsumer:
       return updateContextConsumer(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
@@ -10706,19 +11129,13 @@ if (supportsMutation) {
 function completeWork(current, workInProgress, renderExpirationTime) {
   var newProps = workInProgress.pendingProps;
 
-  if (enableProfilerTimer) {
-    if (workInProgress.mode & ProfileMode) {
-      recordElapsedActualRenderTime(workInProgress);
-    }
-  }
-
   switch (workInProgress.tag) {
     case FunctionalComponent:
-      return null;
+      break;
     case ClassComponent: {
       // We are leaving this subtree, so pop context if any.
       popContextProvider(workInProgress);
-      return null;
+      break;
     }
     case HostRoot: {
       popHostContainer(workInProgress);
@@ -10737,7 +11154,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
         workInProgress.effectTag &= ~Placement;
       }
       updateHostContainer(workInProgress);
-      return null;
+      break;
     }
     case HostComponent: {
       popHostContext(workInProgress);
@@ -10787,7 +11204,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
               "caused by a bug in React. Please file an issue."
           );
           // This can happen when we abort work.
-          return null;
+          break;
         }
 
         var _currentHostContext = getHostContext();
@@ -10843,7 +11260,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           markRef$1(workInProgress);
         }
       }
-      return null;
+      break;
     }
     case HostText: {
       var newText = newProps;
@@ -10860,7 +11277,6 @@ function completeWork(current, workInProgress, renderExpirationTime) {
               "caused by a bug in React. Please file an issue."
           );
           // This can happen when we abort work.
-          return null;
         }
         var _rootContainerInstance = getRootHostContainer();
         var _currentHostContext2 = getHostContext();
@@ -10878,28 +11294,28 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           );
         }
       }
-      return null;
+      break;
     }
     case ForwardRef:
-      return null;
-    case TimeoutComponent:
-      return null;
+      break;
+    case PlaceholderComponent:
+      break;
     case Fragment:
-      return null;
+      break;
     case Mode:
-      return null;
+      break;
     case Profiler:
-      return null;
+      break;
     case HostPortal:
       popHostContainer(workInProgress);
       updateHostContainer(workInProgress);
-      return null;
+      break;
     case ContextProvider:
       // Pop provider fiber
       popProvider(workInProgress);
-      return null;
+      break;
     case ContextConsumer:
-      return null;
+      break;
     // Error cases
     case IndeterminateComponent:
       invariant(
@@ -10916,6 +11332,18 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           "React. Please file an issue."
       );
   }
+
+  if (enableProfilerTimer) {
+    if (workInProgress.mode & ProfileMode) {
+      // Don't record elapsed time unless the "complete" phase has succeeded.
+      // Certain renderers may error during this phase (i.e. ReactNative View/Text nesting validation).
+      // If an error occurs, we'll mark the time while unwinding.
+      // This simplifies the unwinding logic and ensures consistency.
+      recordElapsedActualRenderTime(workInProgress);
+    }
+  }
+
+  return null;
 }
 
 // Module provided by RN:
@@ -11023,6 +11451,8 @@ var invokeGuardedCallback$3 = ReactErrorUtils.invokeGuardedCallback;
 var hasCaughtError$1 = ReactErrorUtils.hasCaughtError;
 var clearCaughtError$1 = ReactErrorUtils.clearCaughtError;
 
+var emptyObject$1 = {};
+
 var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
 {
   didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
@@ -11032,11 +11462,11 @@ function logError(boundary, errorInfo) {
   var source = errorInfo.source;
   var stack = errorInfo.stack;
   if (stack === null && source !== null) {
-    stack = getStackAddendumByWorkInProgressFiber(source);
+    stack = getStackByFiberInDevAndProd(source);
   }
 
   var capturedError = {
-    componentName: source !== null ? getComponentName(source) : null,
+    componentName: source !== null ? getComponentName(source.type) : null,
     componentStack: stack !== null ? stack : "",
     error: errorInfo.value,
     errorBoundary: null,
@@ -11047,7 +11477,7 @@ function logError(boundary, errorInfo) {
 
   if (boundary !== null && boundary.tag === ClassComponent) {
     capturedError.errorBoundary = boundary.stateNode;
-    capturedError.errorBoundaryName = getComponentName(boundary);
+    capturedError.errorBoundaryName = getComponentName(boundary.type);
     capturedError.errorBoundaryFound = true;
     capturedError.willRetry = true;
   }
@@ -11064,40 +11494,40 @@ function logError(boundary, errorInfo) {
   }
 }
 
-var callComponentWillUnmountWithTimer = function(current, instance) {
-  startPhaseTimer(current, "componentWillUnmount");
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
+var callComponentWillUnmountWithTimer = function(current$$1, instance) {
+  startPhaseTimer(current$$1, "componentWillUnmount");
+  instance.props = current$$1.memoizedProps;
+  instance.state = current$$1.memoizedState;
   instance.componentWillUnmount();
   stopPhaseTimer();
 };
 
 // Capture errors so they don't interrupt unmounting.
-function safelyCallComponentWillUnmount(current, instance) {
+function safelyCallComponentWillUnmount(current$$1, instance) {
   {
     invokeGuardedCallback$3(
       null,
       callComponentWillUnmountWithTimer,
       null,
-      current,
+      current$$1,
       instance
     );
     if (hasCaughtError$1()) {
       var unmountError = clearCaughtError$1();
-      captureCommitPhaseError(current, unmountError);
+      captureCommitPhaseError(current$$1, unmountError);
     }
   }
 }
 
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (ref !== null) {
     if (typeof ref === "function") {
       {
         invokeGuardedCallback$3(null, ref, null, null);
         if (hasCaughtError$1()) {
           var refError = clearCaughtError$1();
-          captureCommitPhaseError(current, refError);
+          captureCommitPhaseError(current$$1, refError);
         }
       }
     } else {
@@ -11106,13 +11536,13 @@ function safelyDetachRef(current) {
   }
 }
 
-function commitBeforeMutationLifeCycles(current, finishedWork) {
+function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case ClassComponent: {
       if (finishedWork.effectTag & Snapshot) {
-        if (current !== null) {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
+        if (current$$1 !== null) {
+          var prevProps = current$$1.memoizedProps;
+          var prevState = current$$1.memoizedState;
           startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
           var instance = finishedWork.stateNode;
           instance.props = finishedWork.memoizedProps;
@@ -11122,11 +11552,11 @@ function commitBeforeMutationLifeCycles(current, finishedWork) {
             var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
             if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
               didWarnSet.add(finishedWork.type);
-              warning(
+              warningWithoutStack$1(
                 false,
                 "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
                   "must be returned. You have returned undefined.",
-                getComponentName(finishedWork)
+                getComponentName(finishedWork.type)
               );
             }
           }
@@ -11154,24 +11584,23 @@ function commitBeforeMutationLifeCycles(current, finishedWork) {
 
 function commitLifeCycles(
   finishedRoot,
-  current,
+  current$$1,
   finishedWork,
-  currentTime,
   committedExpirationTime
 ) {
   switch (finishedWork.tag) {
     case ClassComponent: {
       var instance = finishedWork.stateNode;
       if (finishedWork.effectTag & Update) {
-        if (current === null) {
+        if (current$$1 === null) {
           startPhaseTimer(finishedWork, "componentDidMount");
           instance.props = finishedWork.memoizedProps;
           instance.state = finishedWork.memoizedState;
           instance.componentDidMount();
           stopPhaseTimer();
         } else {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
+          var prevProps = current$$1.memoizedProps;
+          var prevState = current$$1.memoizedState;
           startPhaseTimer(finishedWork, "componentDidUpdate");
           instance.props = finishedWork.memoizedProps;
           instance.state = finishedWork.memoizedState;
@@ -11226,7 +11655,7 @@ function commitLifeCycles(
       // (eg DOM renderer may schedule auto-focus for inputs and form controls).
       // These effects should only be committed when components are first mounted,
       // aka when there is no current/alternate.
-      if (current === null && finishedWork.effectTag & Update) {
+      if (current$$1 === null && finishedWork.effectTag & Update) {
         var type = finishedWork.type;
         var props = finishedWork.memoizedProps;
         commitMount(_instance2, type, props, finishedWork);
@@ -11246,8 +11675,23 @@ function commitLifeCycles(
       // We have no life-cycles associated with Profiler.
       return;
     }
-    case TimeoutComponent: {
-      // We have no life-cycles associated with Timeouts.
+    case PlaceholderComponent: {
+      if (enableSuspense) {
+        if ((finishedWork.mode & StrictMode) === NoEffect) {
+          // In loose mode, a placeholder times out by scheduling a synchronous
+          // update in the commit phase. Use `updateQueue` field to signal that
+          // the Timeout needs to switch to the placeholder. We don't need an
+          // entire queue. Any non-null value works.
+          // $FlowFixMe - Intentionally using a value other than an UpdateQueue.
+          finishedWork.updateQueue = emptyObject$1;
+          scheduleWork(finishedWork, Sync);
+        } else {
+          // In strict mode, the Update effect is used to record the time at
+          // which the placeholder timed out.
+          var currentTime = requestCurrentTime();
+          finishedWork.stateNode = { timedOutAt: currentTime };
+        }
+      }
       return;
     }
     default: {
@@ -11277,12 +11721,12 @@ function commitAttachRef(finishedWork) {
     } else {
       {
         if (!ref.hasOwnProperty("current")) {
-          warning(
+          warningWithoutStack$1(
             false,
             "Unexpected ref object provided for %s. " +
               "Use either a ref-setter function or React.createRef().%s",
-            getComponentName(finishedWork),
-            getStackAddendumByWorkInProgressFiber(finishedWork)
+            getComponentName(finishedWork.type),
+            getStackByFiberInDevAndProd(finishedWork)
           );
         }
       }
@@ -11292,8 +11736,8 @@ function commitAttachRef(finishedWork) {
   }
 }
 
-function commitDetachRef(current) {
-  var currentRef = current.ref;
+function commitDetachRef(current$$1) {
+  var currentRef = current$$1.ref;
   if (currentRef !== null) {
     if (typeof currentRef === "function") {
       currentRef(null);
@@ -11306,22 +11750,20 @@ function commitDetachRef(current) {
 // User-originating errors (lifecycles and refs) should not interrupt
 // deletion, so don't let them throw. Host-originating errors should
 // interrupt deletion, so it's okay
-function commitUnmount(current) {
-  if (typeof onCommitUnmount === "function") {
-    onCommitUnmount(current);
-  }
+function commitUnmount(current$$1) {
+  onCommitUnmount(current$$1);
 
-  switch (current.tag) {
+  switch (current$$1.tag) {
     case ClassComponent: {
-      safelyDetachRef(current);
-      var instance = current.stateNode;
+      safelyDetachRef(current$$1);
+      var instance = current$$1.stateNode;
       if (typeof instance.componentWillUnmount === "function") {
-        safelyCallComponentWillUnmount(current, instance);
+        safelyCallComponentWillUnmount(current$$1, instance);
       }
       return;
     }
     case HostComponent: {
-      safelyDetachRef(current);
+      safelyDetachRef(current$$1);
       return;
     }
     case HostPortal: {
@@ -11329,9 +11771,9 @@ function commitUnmount(current) {
       // We are also not using this parent because
       // the portal will get pushed immediately.
       if (supportsMutation) {
-        unmountHostComponents(current);
+        unmountHostComponents(current$$1);
       } else if (supportsPersistence) {
-        emptyPortalContainer(current);
+        emptyPortalContainer(current$$1);
       }
       return;
     }
@@ -11372,26 +11814,26 @@ function commitNestedUnmounts(root) {
   }
 }
 
-function detachFiber(current) {
+function detachFiber(current$$1) {
   // Cut off the return pointers to disconnect it from the tree. Ideally, we
   // should clear the child pointer of the parent alternate to let this
   // get GC:ed but we don't know which for sure which parent is the current
   // one so we'll settle for GC:ing the subtree of this child. This child
   // itself will be GC:ed when the parent updates the next time.
-  current.return = null;
-  current.child = null;
-  if (current.alternate) {
-    current.alternate.child = null;
-    current.alternate.return = null;
+  current$$1.return = null;
+  current$$1.child = null;
+  if (current$$1.alternate) {
+    current$$1.alternate.child = null;
+    current$$1.alternate.return = null;
   }
 }
 
-function emptyPortalContainer(current) {
+function emptyPortalContainer(current$$1) {
   if (!supportsPersistence) {
     return;
   }
 
-  var portal = current.stateNode;
+  var portal = current$$1.stateNode;
   var containerInfo = portal.containerInfo;
 
   var emptyChildSet = createContainerChildSet(containerInfo);
@@ -11501,8 +11943,11 @@ function commitPlacement(finishedWork) {
 
   // Recursively insert all host nodes into the parent.
   var parentFiber = getHostParentFiber(finishedWork);
+
+  // Note: these two variables *must* always be updated together.
   var parent = void 0;
   var isContainer = void 0;
+
   switch (parentFiber.tag) {
     case HostComponent:
       parent = parentFiber.stateNode;
@@ -11572,13 +12017,15 @@ function commitPlacement(finishedWork) {
   }
 }
 
-function unmountHostComponents(current) {
-  // We only have the top Fiber that was inserted but we need recurse down its
-  var node = current;
+function unmountHostComponents(current$$1) {
+  // We only have the top Fiber that was deleted but we need recurse down its
+  var node = current$$1;
 
   // Each iteration, currentParent is populated with node's host parent if not
   // currentParentIsValid.
   var currentParentIsValid = false;
+
+  // Note: these two variables *must* always be updated together.
   var currentParent = void 0;
   var currentParentIsContainer = void 0;
 
@@ -11624,6 +12071,7 @@ function unmountHostComponents(current) {
       // When we go into a portal, it becomes the parent to remove from.
       // We will reassign it back when we pop the portal on the way up.
       currentParent = node.stateNode.containerInfo;
+      currentParentIsContainer = true;
       // Visit children because portals might contain host components.
       if (node.child !== null) {
         node.child.return = node;
@@ -11639,11 +12087,11 @@ function unmountHostComponents(current) {
         continue;
       }
     }
-    if (node === current) {
+    if (node === current$$1) {
       return;
     }
     while (node.sibling === null) {
-      if (node.return === null || node.return === current) {
+      if (node.return === null || node.return === current$$1) {
         return;
       }
       node = node.return;
@@ -11658,19 +12106,19 @@ function unmountHostComponents(current) {
   }
 }
 
-function commitDeletion(current) {
+function commitDeletion(current$$1) {
   if (supportsMutation) {
     // Recursively delete all host nodes from the parent.
     // Detach refs and call componentWillUnmount() on the whole subtree.
-    unmountHostComponents(current);
+    unmountHostComponents(current$$1);
   } else {
     // Detach refs and call componentWillUnmount() on the whole subtree.
-    commitNestedUnmounts(current);
+    commitNestedUnmounts(current$$1);
   }
-  detachFiber(current);
+  detachFiber(current$$1);
 }
 
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   if (!supportsMutation) {
     commitContainer(finishedWork);
     return;
@@ -11688,7 +12136,8 @@ function commitWork(current, finishedWork) {
         // For hydration we reuse the update path but we treat the oldProps
         // as the newProps. The updatePayload will contain the real change in
         // this case.
-        var oldProps = current !== null ? current.memoizedProps : newProps;
+        var oldProps =
+          current$$1 !== null ? current$$1.memoizedProps : newProps;
         var type = finishedWork.type;
         // TODO: Type the updateQueue to be specific to host components.
         var updatePayload = finishedWork.updateQueue;
@@ -11717,7 +12166,7 @@ function commitWork(current, finishedWork) {
       // For hydration we reuse the update path but we treat the oldProps
       // as the newProps. The updatePayload will contain the real change in
       // this case.
-      var oldText = current !== null ? current.memoizedProps : newText;
+      var oldText = current$$1 !== null ? current$$1.memoizedProps : newText;
       commitTextUpdate(textInstance, oldText, newText);
       return;
     }
@@ -11729,16 +12178,16 @@ function commitWork(current, finishedWork) {
         var onRender = finishedWork.memoizedProps.onRender;
         onRender(
           finishedWork.memoizedProps.id,
-          current === null ? "mount" : "update",
+          current$$1 === null ? "mount" : "update",
           finishedWork.actualDuration,
-          finishedWork.treeBaseTime,
+          finishedWork.treeBaseDuration,
           finishedWork.actualStartTime,
           getCommitTime()
         );
       }
       return;
     }
-    case TimeoutComponent: {
+    case PlaceholderComponent: {
       return;
     }
     default: {
@@ -11751,11 +12200,15 @@ function commitWork(current, finishedWork) {
   }
 }
 
-function commitResetTextContent(current) {
+function commitResetTextContent(current$$1) {
   if (!supportsMutation) {
     return;
   }
-  resetTextContent(current.stateNode);
+  resetTextContent(current$$1.stateNode);
+}
+
+function NoopComponent() {
+  return null;
 }
 
 function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
@@ -11812,23 +12265,12 @@ function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
   return update;
 }
 
-function schedulePing(finishedWork) {
-  // Once the promise resolves, we should try rendering the non-
-  // placeholder state again.
-  var currentTime = recalculateCurrentTime();
-  var expirationTime = computeExpirationForFiber(currentTime, finishedWork);
-  var recoveryUpdate = createUpdate(expirationTime);
-  enqueueUpdate(finishedWork, recoveryUpdate, expirationTime);
-  scheduleWork(finishedWork, expirationTime);
-}
-
 function throwException(
   root,
   returnFiber,
   sourceFiber,
   value,
-  renderExpirationTime,
-  currentTimeMs
+  renderExpirationTime
 ) {
   // The source fiber did not complete.
   sourceFiber.effectTag |= Incomplete;
@@ -11844,111 +12286,175 @@ function throwException(
     // This is a thenable.
     var thenable = value;
 
-    // TODO: Should use the earliest known expiration time
-    var expirationTimeMs = expirationTimeToMs(renderExpirationTime);
-    var startTimeMs = expirationTimeMs - 5000;
-    var elapsedMs = currentTimeMs - startTimeMs;
-    if (elapsedMs < 0) {
-      elapsedMs = 0;
-    }
-    var remainingTimeMs = expirationTimeMs - currentTimeMs;
-
-    // Find the earliest timeout of all the timeouts in the ancestor path.
-    // TODO: Alternatively, we could store the earliest timeout on the context
-    // stack, rather than searching on every suspend.
+    // Find the earliest timeout threshold of all the placeholders in the
+    // ancestor path. We could avoid this traversal by storing the thresholds on
+    // the stack, but we choose not to because we only hit this path if we're
+    // IO-bound (i.e. if something suspends). Whereas the stack is used even in
+    // the non-IO- bound case.
     var _workInProgress = returnFiber;
     var earliestTimeoutMs = -1;
-    searchForEarliestTimeout: do {
-      if (_workInProgress.tag === TimeoutComponent) {
+    var startTimeMs = -1;
+    do {
+      if (_workInProgress.tag === PlaceholderComponent) {
         var current = _workInProgress.alternate;
-        if (current !== null && current.memoizedState === true) {
-          // A parent Timeout already committed in a placeholder state. We
-          // need to handle this promise immediately. In other words, we
-          // should never suspend inside a tree that already expired.
-          earliestTimeoutMs = 0;
-          break searchForEarliestTimeout;
+        if (
+          current !== null &&
+          current.memoizedState === true &&
+          current.stateNode !== null
+        ) {
+          // Reached a placeholder that already timed out. Each timed out
+          // placeholder acts as the root of a new suspense boundary.
+
+          // Use the time at which the placeholder timed out as the start time
+          // for the current render.
+          var timedOutAt = current.stateNode.timedOutAt;
+          startTimeMs = expirationTimeToMs(timedOutAt);
+
+          // Do not search any further.
+          break;
         }
-        var timeoutPropMs = _workInProgress.pendingProps.ms;
+        var timeoutPropMs = _workInProgress.pendingProps.delayMs;
         if (typeof timeoutPropMs === "number") {
           if (timeoutPropMs <= 0) {
             earliestTimeoutMs = 0;
-            break searchForEarliestTimeout;
           } else if (
             earliestTimeoutMs === -1 ||
             timeoutPropMs < earliestTimeoutMs
           ) {
             earliestTimeoutMs = timeoutPropMs;
           }
-        } else if (earliestTimeoutMs === -1) {
-          earliestTimeoutMs = remainingTimeMs;
         }
       }
       _workInProgress = _workInProgress.return;
     } while (_workInProgress !== null);
 
-    // Compute the remaining time until the timeout.
-    var msUntilTimeout = earliestTimeoutMs - elapsedMs;
+    // Schedule the nearest Placeholder to re-render the timed out view.
+    _workInProgress = returnFiber;
+    do {
+      if (_workInProgress.tag === PlaceholderComponent) {
+        var didTimeout = _workInProgress.memoizedState;
+        if (!didTimeout) {
+          // Found the nearest boundary.
 
-    if (renderExpirationTime === Never || msUntilTimeout > 0) {
-      // There's still time remaining.
-      markTimeout(root, thenable, msUntilTimeout, renderExpirationTime);
-      var onResolveOrReject = function() {
-        retrySuspendedRoot(root, renderExpirationTime);
-      };
-      thenable.then(onResolveOrReject, onResolveOrReject);
-      return;
-    } else {
-      // No time remaining. Need to fallback to placeholder.
-      // Find the nearest timeout that can be retried.
-      _workInProgress = returnFiber;
-      do {
-        switch (_workInProgress.tag) {
-          case HostRoot: {
-            // The root expired, but no fallback was provided. Throw a
-            // helpful error.
-            var message =
-              renderExpirationTime === Sync
-                ? "A synchronous update was suspended, but no fallback UI " +
-                  "was provided."
-                : "An update was suspended for longer than the timeout, " +
-                  "but no fallback UI was provided.";
-            value = new Error(message);
-            break;
-          }
-          case TimeoutComponent: {
-            if ((_workInProgress.effectTag & DidCapture) === NoEffect) {
-              _workInProgress.effectTag |= ShouldCapture;
-              var _onResolveOrReject = schedulePing.bind(null, _workInProgress);
-              thenable.then(_onResolveOrReject, _onResolveOrReject);
-              return;
+          // If the boundary is not in async mode, we should not suspend, and
+          // likewise, when the promise resolves, we should ping synchronously.
+          var pingTime =
+            (_workInProgress.mode & AsyncMode) === NoEffect
+              ? Sync
+              : renderExpirationTime;
+
+          // Attach a listener to the promise to "ping" the root and retry.
+          var onResolveOrReject = retrySuspendedRoot.bind(
+            null,
+            root,
+            _workInProgress,
+            pingTime
+          );
+          thenable.then(onResolveOrReject, onResolveOrReject);
+
+          // If the boundary is outside of strict mode, we should *not* suspend
+          // the commit. Pretend as if the suspended component rendered null and
+          // keep rendering. In the commit phase, we'll schedule a subsequent
+          // synchronous update to re-render the Placeholder.
+          //
+          // Note: It doesn't matter whether the component that suspended was
+          // inside a strict mode tree. If the Placeholder is outside of it, we
+          // should *not* suspend the commit.
+          if ((_workInProgress.mode & StrictMode) === NoEffect) {
+            _workInProgress.effectTag |= Update;
+
+            // Unmount the source fiber's children
+            var nextChildren = null;
+            reconcileChildren(
+              sourceFiber.alternate,
+              sourceFiber,
+              nextChildren,
+              renderExpirationTime
+            );
+            sourceFiber.effectTag &= ~Incomplete;
+            if (sourceFiber.tag === IndeterminateComponent) {
+              // Let's just assume it's a functional component. This fiber will
+              // be unmounted in the immediate next commit, anyway.
+              sourceFiber.tag = FunctionalComponent;
             }
-            // Already captured during this render. Continue to the next
-            // Timeout ancestor.
-            break;
+
+            if (sourceFiber.tag === ClassComponent) {
+              // We're going to commit this fiber even though it didn't
+              // complete. But we shouldn't call any lifecycle methods or
+              // callbacks. Remove all lifecycle effect tags.
+              sourceFiber.effectTag &= ~LifecycleEffectMask;
+              if (sourceFiber.alternate === null) {
+                // We're about to mount a class component that doesn't have an
+                // instance. Turn this into a dummy functional component instead,
+                // to prevent type errors. This is a bit weird but it's an edge
+                // case and we're about to synchronously delete this
+                // component, anyway.
+                sourceFiber.tag = FunctionalComponent;
+                sourceFiber.type = NoopComponent;
+              }
+            }
+
+            // Exit without suspending.
+            return;
           }
+
+          // Confirmed that the boundary is in a strict mode tree. Continue with
+          // the normal suspend path.
+
+          var absoluteTimeoutMs = void 0;
+          if (earliestTimeoutMs === -1) {
+            // If no explicit threshold is given, default to an abitrarily large
+            // value. The actual size doesn't matter because the threshold for the
+            // whole tree will be clamped to the expiration time.
+            absoluteTimeoutMs = maxSigned31BitInt;
+          } else {
+            if (startTimeMs === -1) {
+              // This suspend happened outside of any already timed-out
+              // placeholders. We don't know exactly when the update was scheduled,
+              // but we can infer an approximate start time from the expiration
+              // time. First, find the earliest uncommitted expiration time in the
+              // tree, including work that is suspended. Then subtract the offset
+              // used to compute an async update's expiration time. This will cause
+              // high priority (interactive) work to expire earlier than neccessary,
+              // but we can account for this by adjusting for the Just Noticable
+              // Difference.
+              var earliestExpirationTime = findEarliestOutstandingPriorityLevel(
+                root,
+                renderExpirationTime
+              );
+              var earliestExpirationTimeMs = expirationTimeToMs(
+                earliestExpirationTime
+              );
+              startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+            }
+            absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+          }
+
+          // Mark the earliest timeout in the suspended fiber's ancestor path.
+          // After completing the root, we'll take the largest of all the
+          // suspended fiber's timeouts and use it to compute a timeout for the
+          // whole tree.
+          renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+
+          _workInProgress.effectTag |= ShouldCapture;
+          _workInProgress.expirationTime = renderExpirationTime;
+          return;
         }
-        _workInProgress = _workInProgress.return;
-      } while (_workInProgress !== null);
-    }
-  } else {
-    // This is an error.
-    markError(root);
-    if (
-      // Retry (at the same priority) one more time before handling the error.
-      // The retry will flush synchronously. (Unless we're already rendering
-      // synchronously, in which case move to the next check.)
-      (!root.didError && renderExpirationTime !== Sync) ||
-      // There's lower priority work. If so, it may have the effect of fixing
-      // the exception that was just thrown.
-      hasLowerPriorityWork(root, renderExpirationTime)
-    ) {
-      return;
-    }
+        // This boundary already captured during this render. Continue to the
+        // next boundary.
+      }
+      _workInProgress = _workInProgress.return;
+    } while (_workInProgress !== null);
+    // No boundary was found. Fallthrough to error mode.
+    value = new Error(
+      "An update was suspended, but no placeholder UI was provided."
+    );
   }
 
   // We didn't find a boundary that could handle this type of exception. Start
   // over and traverse parent path again, this time treating the exception
   // as an error.
+  renderDidError();
   value = createCapturedValue(value, sourceFiber);
   var workInProgress = returnFiber;
   do {
@@ -11956,12 +12462,13 @@ function throwException(
       case HostRoot: {
         var _errorInfo = value;
         workInProgress.effectTag |= ShouldCapture;
+        workInProgress.expirationTime = renderExpirationTime;
         var update = createRootErrorUpdate(
           workInProgress,
           _errorInfo,
           renderExpirationTime
         );
-        enqueueCapturedUpdate(workInProgress, update, renderExpirationTime);
+        enqueueCapturedUpdate(workInProgress, update);
         return;
       }
       case ClassComponent:
@@ -11978,13 +12485,14 @@ function throwException(
               !isAlreadyFailedLegacyErrorBoundary(instance)))
         ) {
           workInProgress.effectTag |= ShouldCapture;
+          workInProgress.expirationTime = renderExpirationTime;
           // Schedule the error boundary to re-render using updated state
           var _update = createClassErrorUpdate(
             workInProgress,
             errorInfo,
             renderExpirationTime
           );
-          enqueueCapturedUpdate(workInProgress, _update, renderExpirationTime);
+          enqueueCapturedUpdate(workInProgress, _update);
           return;
         }
         break;
@@ -12016,17 +12524,19 @@ function unwindWork(workInProgress, renderExpirationTime) {
       popHostContainer(workInProgress);
       popTopLevelContextObject(workInProgress);
       var _effectTag = workInProgress.effectTag;
-      if (_effectTag & ShouldCapture) {
-        workInProgress.effectTag = (_effectTag & ~ShouldCapture) | DidCapture;
-        return workInProgress;
-      }
-      return null;
+      invariant(
+        (_effectTag & DidCapture) === NoEffect,
+        "The root failed to unmount after an error. This is likely a bug in " +
+          "React. Please file an issue."
+      );
+      workInProgress.effectTag = (_effectTag & ~ShouldCapture) | DidCapture;
+      return workInProgress;
     }
     case HostComponent: {
       popHostContext(workInProgress);
       return null;
     }
-    case TimeoutComponent: {
+    case PlaceholderComponent: {
       var _effectTag2 = workInProgress.effectTag;
       if (_effectTag2 & ShouldCapture) {
         workInProgress.effectTag = (_effectTag2 & ~ShouldCapture) | DidCapture;
@@ -12048,8 +12558,6 @@ function unwindWork(workInProgress, renderExpirationTime) {
 function unwindInterruptedWork(interruptedWork) {
   if (enableProfilerTimer) {
     if (interruptedWork.mode & ProfileMode) {
-      // Resume in case we're picking up on work that was paused.
-      resumeActualRenderTimerIfPaused();
       recordElapsedActualRenderTime(interruptedWork);
     }
   }
@@ -12079,6 +12587,11 @@ function unwindInterruptedWork(interruptedWork) {
   }
 }
 
+var Dispatcher = {
+  readContext: readContext
+};
+
+var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
 var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback;
 var hasCaughtError = ReactErrorUtils.hasCaughtError;
 var clearCaughtError = ReactErrorUtils.clearCaughtError;
@@ -12096,28 +12609,28 @@ var warnAboutInvalidUpdates = void 0;
   warnAboutUpdateOnUnmounted = function(fiber) {
     // We show the whole stack but dedupe on the top component's name because
     // the problematic code almost always lies inside that component.
-    var componentName = getComponentName(fiber) || "ReactClass";
+    var componentName = getComponentName(fiber.type) || "ReactClass";
     if (didWarnStateUpdateForUnmountedComponent[componentName]) {
       return;
     }
-    warning(
+    warningWithoutStack$1(
       false,
       "Can't call setState (or forceUpdate) on an unmounted component. This " +
         "is a no-op, but it indicates a memory leak in your application. To " +
         "fix, cancel all subscriptions and asynchronous tasks in the " +
         "componentWillUnmount method.%s",
-      getStackAddendumByWorkInProgressFiber(fiber)
+      getStackByFiberInDevAndProd(fiber)
     );
     didWarnStateUpdateForUnmountedComponent[componentName] = true;
   };
 
   warnAboutInvalidUpdates = function(instance) {
-    switch (ReactDebugCurrentFiber.phase) {
+    switch (phase) {
       case "getChildContext":
         if (didWarnSetStateChildContext) {
           return;
         }
-        warning(
+        warningWithoutStack$1(
           false,
           "setState(...): Cannot call setState() inside getChildContext()"
         );
@@ -12127,7 +12640,7 @@ var warnAboutInvalidUpdates = void 0;
         if (didWarnAboutStateTransition) {
           return;
         }
-        warning(
+        warningWithoutStack$1(
           false,
           "Cannot update during an existing state transition (such as within " +
             "`render` or another component's constructor). Render methods should " +
@@ -12140,12 +12653,7 @@ var warnAboutInvalidUpdates = void 0;
   };
 }
 
-// Represents the current time in ms.
-var originalStartTimeMs = now();
-var mostRecentCurrentTime = msToExpirationTime(0);
-var mostRecentCurrentTimeMs = originalStartTimeMs;
-
-// Used to ensure computeUniqueAsyncExpiration is monotonically increases.
+// Used to ensure computeUniqueAsyncExpiration is monotonically increasing.
 var lastUniqueAsyncExpiration = 0;
 
 // Represents the expiration time that incoming updates should use. (If this
@@ -12160,7 +12668,7 @@ var nextUnitOfWork = null;
 var nextRoot = null;
 // The time at which we're currently rendering work.
 var nextRenderExpirationTime = NoWork;
-var nextLatestTimeoutMs = -1;
+var nextLatestAbsoluteTimeoutMs = -1;
 var nextRenderDidError = false;
 
 // The next fiber with an effect that we're currently committing.
@@ -12197,7 +12705,7 @@ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
     // Restore the original state of the work-in-progress
     if (stashedWorkInProgressProperties === null) {
       // This should never happen. Don't throw because this code is DEV-only.
-      warning(
+      warningWithoutStack$1(
         false,
         "Could not replay rendering after an error. This is likely a bug in React. " +
           "Please file an issue."
@@ -12259,6 +12767,12 @@ function resetStack() {
   if (nextUnitOfWork !== null) {
     var interruptedWork = nextUnitOfWork.return;
     while (interruptedWork !== null) {
+      if (enableProfilerTimer) {
+        if (interruptedWork.mode & ProfileMode) {
+          // Resume in case we're picking up on work that was paused.
+          resumeActualRenderTimerIfPaused(false);
+        }
+      }
       unwindInterruptedWork(interruptedWork);
       interruptedWork = interruptedWork.return;
     }
@@ -12271,7 +12785,7 @@ function resetStack() {
 
   nextRoot = null;
   nextRenderExpirationTime = NoWork;
-  nextLatestTimeoutMs = -1;
+  nextLatestAbsoluteTimeoutMs = -1;
   nextRenderDidError = false;
   nextUnitOfWork = null;
 }
@@ -12279,7 +12793,7 @@ function resetStack() {
 function commitAllHostEffects() {
   while (nextEffect !== null) {
     {
-      ReactDebugCurrentFiber.setCurrentFiber(nextEffect);
+      setCurrentFiber(nextEffect);
     }
     recordEffect();
 
@@ -12290,9 +12804,9 @@ function commitAllHostEffects() {
     }
 
     if (effectTag & Ref) {
-      var current = nextEffect.alternate;
-      if (current !== null) {
-        commitDetachRef(current);
+      var current$$1 = nextEffect.alternate;
+      if (current$$1 !== null) {
+        commitDetachRef(current$$1);
       }
     }
 
@@ -12338,31 +12852,34 @@ function commitAllHostEffects() {
   }
 
   {
-    ReactDebugCurrentFiber.resetCurrentFiber();
+    resetCurrentFiber();
   }
 }
 
 function commitBeforeMutationLifecycles() {
   while (nextEffect !== null) {
-    var effectTag = nextEffect.effectTag;
+    {
+      setCurrentFiber(nextEffect);
+    }
 
+    var effectTag = nextEffect.effectTag;
     if (effectTag & Snapshot) {
       recordEffect();
-      var current = nextEffect.alternate;
-      commitBeforeMutationLifeCycles(current, nextEffect);
+      var current$$1 = nextEffect.alternate;
+      commitBeforeMutationLifeCycles(current$$1, nextEffect);
     }
 
     // Don't cleanup effects yet;
     // This will be done by commitAllLifeCycles()
     nextEffect = nextEffect.nextEffect;
   }
+
+  {
+    resetCurrentFiber();
+  }
 }
 
-function commitAllLifeCycles(
-  finishedRoot,
-  currentTime,
-  committedExpirationTime
-) {
+function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
   {
     ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
 
@@ -12379,12 +12896,11 @@ function commitAllLifeCycles(
 
     if (effectTag & (Update | Callback)) {
       recordEffect();
-      var current = nextEffect.alternate;
+      var current$$1 = nextEffect.alternate;
       commitLifeCycles(
         finishedRoot,
-        current,
+        current$$1,
         nextEffect,
-        currentTime,
         committedExpirationTime
       );
     }
@@ -12443,12 +12959,18 @@ function commitRoot(root, finishedWork) {
   // Update the pending priority levels to account for the work that we are
   // about to commit. This needs to happen before calling the lifecycles, since
   // they may schedule additional updates.
-  var earliestRemainingTime = finishedWork.expirationTime;
-  var currentTime = recalculateCurrentTime();
-  markCommittedPriorityLevels(root, currentTime, earliestRemainingTime);
+  var updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+  var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+  var earliestRemainingTimeBeforeCommit =
+    updateExpirationTimeBeforeCommit === NoWork ||
+    (childExpirationTimeBeforeCommit !== NoWork &&
+      childExpirationTimeBeforeCommit < updateExpirationTimeBeforeCommit)
+      ? childExpirationTimeBeforeCommit
+      : updateExpirationTimeBeforeCommit;
+  markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
 
   // Reset this to null before calling lifecycles
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
 
   var firstEffect = void 0;
   if (finishedWork.effectTag > PerformedWork) {
@@ -12556,7 +13078,6 @@ function commitRoot(root, finishedWork) {
         commitAllLifeCycles,
         null,
         root,
-        currentTime,
         committedExpirationTime
       );
       if (hasCaughtError()) {
@@ -12579,84 +13100,100 @@ function commitRoot(root, finishedWork) {
 
   if (enableProfilerTimer) {
     {
-      checkActualRenderTimeStackEmpty();
+      if (nextRoot === null) {
+        // Only check this stack once we're done processing async work.
+        // This prevents a false positive that occurs after a batched commit,
+        // If there was in-progress async work before the commit.
+        checkActualRenderTimeStackEmpty();
+      }
     }
-    resetActualRenderTimer();
   }
 
   isCommitting$1 = false;
   isWorking = false;
   stopCommitLifeCyclesTimer();
   stopCommitTimer();
-  if (typeof onCommitRoot === "function") {
-    onCommitRoot(finishedWork.stateNode);
-  }
+  onCommitRoot(finishedWork.stateNode);
   if (true && ReactFiberInstrumentation_1.debugTool) {
     ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
   }
 
-  var expirationTime = root.expirationTime;
-  if (expirationTime === NoWork) {
+  var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+  var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+  var earliestRemainingTimeAfterCommit =
+    updateExpirationTimeAfterCommit === NoWork ||
+    (childExpirationTimeAfterCommit !== NoWork &&
+      childExpirationTimeAfterCommit < updateExpirationTimeAfterCommit)
+      ? childExpirationTimeAfterCommit
+      : updateExpirationTimeAfterCommit;
+  if (earliestRemainingTimeAfterCommit === NoWork) {
     // If there's no remaining work, we can clear the set of already failed
     // error boundaries.
     legacyErrorBoundariesThatAlreadyFailed = null;
   }
-  onCommit(root, expirationTime);
+  onCommit(root, earliestRemainingTimeAfterCommit);
 }
 
-function resetExpirationTime(workInProgress, renderTime) {
-  if (renderTime !== Never && workInProgress.expirationTime === Never) {
+function resetChildExpirationTime(workInProgress, renderTime) {
+  if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
     // The children of this component are hidden. Don't bubble their
     // expiration times.
     return;
   }
 
-  // Check for pending updates.
-  var newExpirationTime = NoWork;
-  switch (workInProgress.tag) {
-    case HostRoot:
-    case ClassComponent: {
-      var updateQueue = workInProgress.updateQueue;
-      if (updateQueue !== null) {
-        newExpirationTime = updateQueue.expirationTime;
-      }
-    }
-  }
-
-  // TODO: Calls need to visit stateNode
+  var newChildExpirationTime = NoWork;
 
   // Bubble up the earliest expiration time.
-  // (And "base" render timers if that feature flag is enabled)
   if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
-    var treeBaseTime = workInProgress.selfBaseTime;
+    // We're in profiling mode. Let's use this same traversal to update the
+    // "base" render times.
+    var treeBaseDuration = workInProgress.selfBaseDuration;
     var child = workInProgress.child;
     while (child !== null) {
-      treeBaseTime += child.treeBaseTime;
+      var childUpdateExpirationTime = child.expirationTime;
+      var childChildExpirationTime = child.childExpirationTime;
       if (
-        child.expirationTime !== NoWork &&
-        (newExpirationTime === NoWork ||
-          newExpirationTime > child.expirationTime)
+        newChildExpirationTime === NoWork ||
+        (childUpdateExpirationTime !== NoWork &&
+          childUpdateExpirationTime < newChildExpirationTime)
       ) {
-        newExpirationTime = child.expirationTime;
+        newChildExpirationTime = childUpdateExpirationTime;
       }
+      if (
+        newChildExpirationTime === NoWork ||
+        (childChildExpirationTime !== NoWork &&
+          childChildExpirationTime < newChildExpirationTime)
+      ) {
+        newChildExpirationTime = childChildExpirationTime;
+      }
+      treeBaseDuration += child.treeBaseDuration;
       child = child.sibling;
     }
-    workInProgress.treeBaseTime = treeBaseTime;
+    workInProgress.treeBaseDuration = treeBaseDuration;
   } else {
     var _child = workInProgress.child;
     while (_child !== null) {
+      var _childUpdateExpirationTime = _child.expirationTime;
+      var _childChildExpirationTime = _child.childExpirationTime;
       if (
-        _child.expirationTime !== NoWork &&
-        (newExpirationTime === NoWork ||
-          newExpirationTime > _child.expirationTime)
+        newChildExpirationTime === NoWork ||
+        (_childUpdateExpirationTime !== NoWork &&
+          _childUpdateExpirationTime < newChildExpirationTime)
       ) {
-        newExpirationTime = _child.expirationTime;
+        newChildExpirationTime = _childUpdateExpirationTime;
+      }
+      if (
+        newChildExpirationTime === NoWork ||
+        (_childChildExpirationTime !== NoWork &&
+          _childChildExpirationTime < newChildExpirationTime)
+      ) {
+        newChildExpirationTime = _childChildExpirationTime;
       }
       _child = _child.sibling;
     }
   }
 
-  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.childExpirationTime = newChildExpirationTime;
 }
 
 function completeUnitOfWork(workInProgress) {
@@ -12668,9 +13205,9 @@ function completeUnitOfWork(workInProgress) {
     // Ideally nothing should rely on this, but relying on it here
     // means that we don't need an additional field on the work in
     // progress.
-    var current = workInProgress.alternate;
+    var current$$1 = workInProgress.alternate;
     {
-      ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
+      setCurrentFiber(workInProgress);
     }
 
     var returnFiber = workInProgress.return;
@@ -12678,15 +13215,16 @@ function completeUnitOfWork(workInProgress) {
 
     if ((workInProgress.effectTag & Incomplete) === NoEffect) {
       // This fiber completed.
-      var next = completeWork(
-        current,
+      nextUnitOfWork = completeWork(
+        current$$1,
         workInProgress,
         nextRenderExpirationTime
       );
+      var next = nextUnitOfWork;
       stopWorkTimer(workInProgress);
-      resetExpirationTime(workInProgress, nextRenderExpirationTime);
+      resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
       {
-        ReactDebugCurrentFiber.resetCurrentFiber();
+        resetCurrentFiber();
       }
 
       if (next !== null) {
@@ -12765,7 +13303,7 @@ function completeUnitOfWork(workInProgress) {
       }
 
       {
-        ReactDebugCurrentFiber.resetCurrentFiber();
+        resetCurrentFiber();
       }
 
       if (_next !== null) {
@@ -12773,6 +13311,7 @@ function completeUnitOfWork(workInProgress) {
         if (true && ReactFiberInstrumentation_1.debugTool) {
           ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
         }
+
         // If completing this work spawned new work, do that next. We'll come
         // back here again.
         // Since we're restarting, remove anything that is not a host effect
@@ -12815,12 +13354,12 @@ function performUnitOfWork(workInProgress) {
   // Ideally nothing should rely on this, but relying on it here
   // means that we don't need an additional field on the work in
   // progress.
-  var current = workInProgress.alternate;
+  var current$$1 = workInProgress.alternate;
 
   // See if beginning this work spawns more work.
   startWorkTimer(workInProgress);
   {
-    ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
+    setCurrentFiber(workInProgress);
   }
 
   if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
@@ -12836,7 +13375,7 @@ function performUnitOfWork(workInProgress) {
       startBaseRenderTimer();
     }
 
-    next = beginWork(current, workInProgress, nextRenderExpirationTime);
+    next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
 
     if (workInProgress.mode & ProfileMode) {
       // Update "base" time if the render wasn't bailed out on.
@@ -12844,11 +13383,11 @@ function performUnitOfWork(workInProgress) {
       stopBaseRenderTimerIfRunning();
     }
   } else {
-    next = beginWork(current, workInProgress, nextRenderExpirationTime);
+    next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
   }
 
   {
-    ReactDebugCurrentFiber.resetCurrentFiber();
+    resetCurrentFiber();
     if (isReplayingFailedUnitOfWork) {
       // Currently replaying a failed unit of work. This should be unreachable,
       // because the render phase is meant to be idempotent, and it should
@@ -12866,7 +13405,7 @@ function performUnitOfWork(workInProgress) {
     next = completeUnitOfWork(workInProgress);
   }
 
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
 
   return next;
 }
@@ -12891,13 +13430,14 @@ function workLoop(isYieldy) {
   }
 }
 
-function renderRoot(root, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused " +
       "by a bug in React. Please file an issue."
   );
   isWorking = true;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
 
   var expirationTime = root.nextExpirationTimeToWorkOn;
 
@@ -12912,8 +13452,6 @@ function renderRoot(root, isYieldy) {
     resetStack();
     nextRoot = root;
     nextRenderExpirationTime = expirationTime;
-    nextLatestTimeoutMs = -1;
-    nextRenderDidError = false;
     nextUnitOfWork = createWorkInProgress(
       nextRoot.current,
       null,
@@ -12972,17 +13510,17 @@ function renderRoot(root, isYieldy) {
           // for now.
           didFatal = true;
           onUncaughtError(thrownValue);
-          break;
+        } else {
+          throwException(
+            root,
+            returnFiber,
+            sourceFiber,
+            thrownValue,
+            nextRenderExpirationTime
+          );
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        throwException(
-          root,
-          returnFiber,
-          sourceFiber,
-          thrownValue,
-          nextRenderExpirationTime,
-          mostRecentCurrentTimeMs
-        );
-        nextUnitOfWork = completeUnitOfWork(sourceFiber);
       }
     }
     break;
@@ -12990,52 +13528,139 @@ function renderRoot(root, isYieldy) {
 
   // We're done performing work. Time to clean up.
   isWorking = false;
+  ReactCurrentOwner$2.currentDispatcher = null;
+  resetContextDependences();
 
   // Yield back to main thread.
   if (didFatal) {
-    var didCompleteRoot = false;
-    stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+    var _didCompleteRoot = false;
+    stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
     interruptedBy = null;
     // There was a fatal error.
     {
       resetStackAfterFatalErrorInDev();
+
+      // Reset the DEV fiber stack in case we're profiling roots.
+      // (We do this for profiling bulds when DevTools is detected.)
+      resetActualRenderTimerStackAfterFatalErrorInDev();
     }
+    // `nextRoot` points to the in-progress root. A non-null value indicates
+    // that we're in the middle of an async render. Set it to null to indicate
+    // there's no more work to be done in the current batch.
+    nextRoot = null;
     onFatal(root);
-  } else if (nextUnitOfWork === null) {
-    // We reached the root.
-    var rootWorkInProgress = root.current.alternate;
-    invariant(
-      rootWorkInProgress !== null,
-      "Finished root should have a work-in-progress. This error is likely " +
-        "caused by a bug in React. Please file an issue."
-    );
-    if ((rootWorkInProgress.effectTag & Incomplete) === NoEffect) {
-      var _didCompleteRoot = true;
-      stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
-      interruptedBy = null;
-      // The root successfully completed.
-      onComplete(root, rootWorkInProgress, expirationTime);
-    } else {
-      // The root did not complete.
-      var _didCompleteRoot2 = false;
-      stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
-      interruptedBy = null;
-      markSuspendedPriorityLevel(root, expirationTime, nextRenderDidError);
-      var suspendedExpirationTime = expirationTime;
-      var newExpirationTime = root.expirationTime;
-      onSuspend(
-        root,
-        suspendedExpirationTime,
-        newExpirationTime,
-        nextLatestTimeoutMs
-      );
-    }
-  } else {
-    var _didCompleteRoot3 = false;
-    stopWorkLoopTimer(interruptedBy, _didCompleteRoot3);
+    return;
+  }
+
+  if (nextUnitOfWork !== null) {
+    // There's still remaining async work in this tree, but we ran out of time
+    // in the current frame. Yield back to the renderer. Unless we're
+    // interrupted by a higher priority update, we'll continue later from where
+    // we left off.
+    var _didCompleteRoot2 = false;
+    stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
     interruptedBy = null;
     onYield(root);
+    return;
   }
+
+  // We completed the whole tree.
+  var didCompleteRoot = true;
+  stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+  var rootWorkInProgress = root.current.alternate;
+  invariant(
+    rootWorkInProgress !== null,
+    "Finished root should have a work-in-progress. This error is likely " +
+      "caused by a bug in React. Please file an issue."
+  );
+
+  // `nextRoot` points to the in-progress root. A non-null value indicates
+  // that we're in the middle of an async render. Set it to null to indicate
+  // there's no more work to be done in the current batch.
+  nextRoot = null;
+  interruptedBy = null;
+
+  if (nextRenderDidError) {
+    // There was an error
+    if (hasLowerPriorityWork(root, expirationTime)) {
+      // There's lower priority work. If so, it may have the effect of fixing
+      // the exception that was just thrown. Exit without committing. This is
+      // similar to a suspend, but without a timeout because we're not waiting
+      // for a promise to resolve. React will restart at the lower
+      // priority level.
+      markSuspendedPriorityLevel(root, expirationTime);
+      var suspendedExpirationTime = expirationTime;
+      var rootExpirationTime = root.expirationTime;
+      onSuspend(
+        root,
+        rootWorkInProgress,
+        suspendedExpirationTime,
+        rootExpirationTime,
+        -1 // Indicates no timeout
+      );
+      return;
+    } else if (
+      // There's no lower priority work, but we're rendering asynchronously.
+      // Synchronsouly attempt to render the same level one more time. This is
+      // similar to a suspend, but without a timeout because we're not waiting
+      // for a promise to resolve.
+      !root.didError &&
+      !isExpired
+    ) {
+      root.didError = true;
+      var _suspendedExpirationTime = (root.nextExpirationTimeToWorkOn = expirationTime);
+      var _rootExpirationTime = (root.expirationTime = Sync);
+      onSuspend(
+        root,
+        rootWorkInProgress,
+        _suspendedExpirationTime,
+        _rootExpirationTime,
+        -1 // Indicates no timeout
+      );
+      return;
+    }
+  }
+
+  if (enableSuspense && !isExpired && nextLatestAbsoluteTimeoutMs !== -1) {
+    // The tree was suspended.
+    var _suspendedExpirationTime2 = expirationTime;
+    markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+
+    // Find the earliest uncommitted expiration time in the tree, including
+    // work that is suspended. The timeout threshold cannot be longer than
+    // the overall expiration.
+    var earliestExpirationTime = findEarliestOutstandingPriorityLevel(
+      root,
+      expirationTime
+    );
+    var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+    if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+      nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+    }
+
+    // Subtract the current time from the absolute timeout to get the number
+    // of milliseconds until the timeout. In other words, convert an absolute
+    // timestamp to a relative time. This is the value that is passed
+    // to `setTimeout`.
+    var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+    var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+    msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+
+    // TODO: Account for the Just Noticable Difference
+
+    var _rootExpirationTime2 = root.expirationTime;
+    onSuspend(
+      root,
+      rootWorkInProgress,
+      _suspendedExpirationTime2,
+      _rootExpirationTime2,
+      msUntilTimeout
+    );
+    return;
+  }
+
+  // Ready to commit.
+  onComplete(root, rootWorkInProgress, expirationTime);
 }
 
 function dispatch(sourceFiber, value, expirationTime) {
@@ -13057,7 +13682,7 @@ function dispatch(sourceFiber, value, expirationTime) {
         ) {
           var errorInfo = createCapturedValue(value, sourceFiber);
           var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
-          enqueueUpdate(fiber, update, expirationTime);
+          enqueueUpdate(fiber, update);
           scheduleWork(fiber, expirationTime);
           return;
         }
@@ -13065,7 +13690,7 @@ function dispatch(sourceFiber, value, expirationTime) {
       case HostRoot: {
         var _errorInfo = createCapturedValue(value, sourceFiber);
         var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
-        enqueueUpdate(fiber, _update, expirationTime);
+        enqueueUpdate(fiber, _update);
         scheduleWork(fiber, expirationTime);
         return;
       }
@@ -13083,7 +13708,7 @@ function dispatch(sourceFiber, value, expirationTime) {
       _errorInfo2,
       expirationTime
     );
-    enqueueUpdate(rootFiber, _update2, expirationTime);
+    enqueueUpdate(rootFiber, _update2);
     scheduleWork(rootFiber, expirationTime);
   }
 }
@@ -13092,36 +13717,9 @@ function captureCommitPhaseError(fiber, error) {
   return dispatch(fiber, error, Sync);
 }
 
-function computeAsyncExpiration(currentTime) {
-  // Given the current clock time, returns an expiration time. We use rounding
-  // to batch like updates together.
-  // Should complete within ~5000ms. 5250ms max.
-  var expirationMs = 5000;
-  var bucketSizeMs = 250;
-  return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
-}
-
-function computeInteractiveExpiration(currentTime) {
-  var expirationMs = void 0;
-  // We intentionally set a higher expiration time for interactive updates in
-  // dev than in production.
-  // If the main thread is being blocked so long that you hit the expiration,
-  // it's a problem that could be solved with better scheduling.
-  // People will be more likely to notice this and fix it with the long
-  // expiration time in development.
-  // In production we opt for better UX at the risk of masking scheduling
-  // problems, by expiring fast.
-  {
-    // Should complete within ~500ms. 600ms max.
-    expirationMs = 500;
-  }
-  var bucketSizeMs = 100;
-  return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
-}
-
 // Creates a unique async expiration time.
 function computeUniqueAsyncExpiration() {
-  var currentTime = recalculateCurrentTime();
+  var currentTime = requestCurrentTime();
   var result = computeAsyncExpiration(currentTime);
   if (result <= lastUniqueAsyncExpiration) {
     // Since we assume the current time monotonically increases, we only hit
@@ -13159,6 +13757,11 @@ function computeExpirationForFiber(currentTime, fiber) {
         // This is an async update
         expirationTime = computeAsyncExpiration(currentTime);
       }
+      // If we're in the middle of rendering a tree, do not update at the same
+      // expiration time that is already rendering.
+      if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+        expirationTime += 1;
+      }
     } else {
       // This is a sync update
       expirationTime = Sync;
@@ -13178,25 +13781,93 @@ function computeExpirationForFiber(currentTime, fiber) {
   return expirationTime;
 }
 
-function markTimeout(root, thenable, timeoutMs, suspendedTime) {
+function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
   // Schedule the timeout.
-  if (timeoutMs >= 0 && nextLatestTimeoutMs < timeoutMs) {
-    nextLatestTimeoutMs = timeoutMs;
+  if (
+    absoluteTimeoutMs >= 0 &&
+    nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs
+  ) {
+    nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
   }
 }
 
-function markError(root) {
+function renderDidError() {
   nextRenderDidError = true;
 }
 
-function retrySuspendedRoot(root, suspendedTime) {
-  markPingedPriorityLevel(root, suspendedTime);
-  var retryTime = root.expirationTime;
-  if (retryTime !== NoWork) {
-    requestWork(root, retryTime);
+function retrySuspendedRoot(root, fiber, suspendedTime) {
+  if (enableSuspense) {
+    var retryTime = void 0;
+
+    if (isPriorityLevelSuspended(root, suspendedTime)) {
+      // Ping at the original level
+      retryTime = suspendedTime;
+      markPingedPriorityLevel(root, retryTime);
+    } else {
+      // Placeholder already timed out. Compute a new expiration time
+      var currentTime = requestCurrentTime();
+      retryTime = computeExpirationForFiber(currentTime, fiber);
+      markPendingPriorityLevel(root, retryTime);
+    }
+
+    scheduleWorkToRoot(fiber, retryTime);
+    var rootExpirationTime = root.expirationTime;
+    if (rootExpirationTime !== NoWork) {
+      requestWork(root, rootExpirationTime);
+    }
   }
 }
 
+function scheduleWorkToRoot(fiber, expirationTime) {
+  // Update the source fiber's expiration time
+  if (
+    fiber.expirationTime === NoWork ||
+    fiber.expirationTime > expirationTime
+  ) {
+    fiber.expirationTime = expirationTime;
+  }
+  var alternate = fiber.alternate;
+  if (
+    alternate !== null &&
+    (alternate.expirationTime === NoWork ||
+      alternate.expirationTime > expirationTime)
+  ) {
+    alternate.expirationTime = expirationTime;
+  }
+  // Walk the parent path to the root and update the child expiration time.
+  var node = fiber.return;
+  if (node === null && fiber.tag === HostRoot) {
+    return fiber.stateNode;
+  }
+  while (node !== null) {
+    alternate = node.alternate;
+    if (
+      node.childExpirationTime === NoWork ||
+      node.childExpirationTime > expirationTime
+    ) {
+      node.childExpirationTime = expirationTime;
+      if (
+        alternate !== null &&
+        (alternate.childExpirationTime === NoWork ||
+          alternate.childExpirationTime > expirationTime)
+      ) {
+        alternate.childExpirationTime = expirationTime;
+      }
+    } else if (
+      alternate !== null &&
+      (alternate.childExpirationTime === NoWork ||
+        alternate.childExpirationTime > expirationTime)
+    ) {
+      alternate.childExpirationTime = expirationTime;
+    }
+    if (node.return === null && node.tag === HostRoot) {
+      return node.stateNode;
+    }
+    node = node.return;
+  }
+  return null;
+}
+
 function scheduleWork(fiber, expirationTime) {
   recordScheduleUpdate();
 
@@ -13207,80 +13878,51 @@ function scheduleWork(fiber, expirationTime) {
     }
   }
 
-  var node = fiber;
-  while (node !== null) {
-    // Walk the parent path to the root and update each node's
-    // expiration time.
-    if (
-      node.expirationTime === NoWork ||
-      node.expirationTime > expirationTime
-    ) {
-      node.expirationTime = expirationTime;
+  var root = scheduleWorkToRoot(fiber, expirationTime);
+  if (root === null) {
+    if (true && fiber.tag === ClassComponent) {
+      warnAboutUpdateOnUnmounted(fiber);
     }
-    if (node.alternate !== null) {
-      if (
-        node.alternate.expirationTime === NoWork ||
-        node.alternate.expirationTime > expirationTime
-      ) {
-        node.alternate.expirationTime = expirationTime;
-      }
-    }
-    if (node.return === null) {
-      if (node.tag === HostRoot) {
-        var root = node.stateNode;
-        if (
-          !isWorking &&
-          nextRenderExpirationTime !== NoWork &&
-          expirationTime < nextRenderExpirationTime
-        ) {
-          // This is an interruption. (Used for performance tracking.)
-          interruptedBy = fiber;
-          resetStack();
-        }
-        markPendingPriorityLevel(root, expirationTime);
-        if (
-          // If we're in the render phase, we don't need to schedule this root
-          // for an update, because we'll do it before we exit...
-          !isWorking ||
-          isCommitting$1 ||
-          // ...unless this is a different root than the one we're rendering.
-          nextRoot !== root
-        ) {
-          var rootExpirationTime = root.expirationTime;
-          requestWork(root, rootExpirationTime);
-        }
-        if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
-          invariant(
-            false,
-            "Maximum update depth exceeded. This can happen when a " +
-              "component repeatedly calls setState inside " +
-              "componentWillUpdate or componentDidUpdate. React limits " +
-              "the number of nested updates to prevent infinite loops."
-          );
-        }
-      } else {
-        {
-          if (fiber.tag === ClassComponent) {
-            warnAboutUpdateOnUnmounted(fiber);
-          }
-        }
-        return;
-      }
-    }
-    node = node.return;
+    return;
+  }
+
+  if (
+    !isWorking &&
+    nextRenderExpirationTime !== NoWork &&
+    expirationTime < nextRenderExpirationTime
+  ) {
+    // This is an interruption. (Used for performance tracking.)
+    interruptedBy = fiber;
+    resetStack();
+  }
+  markPendingPriorityLevel(root, expirationTime);
+  if (
+    // If we're in the render phase, we don't need to schedule this root
+    // for an update, because we'll do it before we exit...
+    !isWorking ||
+    isCommitting$1 ||
+    // ...unless this is a different root than the one we're rendering.
+    nextRoot !== root
+  ) {
+    var rootExpirationTime = root.expirationTime;
+    requestWork(root, rootExpirationTime);
+  }
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    // Reset this back to zero so subsequent updates don't throw.
+    nestedUpdateCount = 0;
+    invariant(
+      false,
+      "Maximum update depth exceeded. This can happen when a " +
+        "component repeatedly calls setState inside " +
+        "componentWillUpdate or componentDidUpdate. React limits " +
+        "the number of nested updates to prevent infinite loops."
+    );
   }
 }
 
-function recalculateCurrentTime() {
-  // Subtract initial time so it fits inside 32bits
-  mostRecentCurrentTimeMs = now() - originalStartTimeMs;
-  mostRecentCurrentTime = msToExpirationTime(mostRecentCurrentTimeMs);
-  return mostRecentCurrentTime;
-}
-
 function deferredUpdates(fn) {
+  var currentTime = requestCurrentTime();
   var previousExpirationContext = expirationContext;
-  var currentTime = recalculateCurrentTime();
   expirationContext = computeAsyncExpiration(currentTime);
   try {
     return fn();
@@ -13288,6 +13930,7 @@ function deferredUpdates(fn) {
     expirationContext = previousExpirationContext;
   }
 }
+
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
   expirationContext = Sync;
@@ -13322,12 +13965,22 @@ var isBatchingInteractiveUpdates = false;
 
 var completedBatches = null;
 
+var originalStartTimeMs = now();
+var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+var currentSchedulerTime = currentRendererTime;
+
 // Use these to prevent an infinite loop of nested updates
-var NESTED_UPDATE_LIMIT = 1000;
+var NESTED_UPDATE_LIMIT = 50;
 var nestedUpdateCount = 0;
+var lastCommittedRootDuringThisBatch = null;
 
 var timeHeuristicForUnitOfWork = 1;
 
+function recomputeCurrentRendererTime() {
+  var currentTimeMs = now() - originalStartTimeMs;
+  currentRendererTime = msToExpirationTime(currentTimeMs);
+}
+
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (callbackExpirationTime !== NoWork) {
     // A callback is already scheduled. Check its expiration time (timeout).
@@ -13366,30 +14019,98 @@ function onComplete(root, finishedWork, expirationTime) {
   root.finishedWork = finishedWork;
 }
 
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  if (timeoutMs >= 0) {
-    var suspendedRoot = root;
-    setTimeout(function() {
-      retrySuspendedRoot(suspendedRoot, suspendedExpirationTime);
-    }, timeoutMs);
+function onSuspend(
+  root,
+  finishedWork,
+  suspendedExpirationTime,
+  rootExpirationTime,
+  msUntilTimeout
+) {
+  root.expirationTime = rootExpirationTime;
+  if (enableSuspense && msUntilTimeout === 0 && !shouldYield()) {
+    // Don't wait an additional tick. Commit the tree immediately.
+    root.pendingCommitExpirationTime = suspendedExpirationTime;
+    root.finishedWork = finishedWork;
+  } else if (msUntilTimeout > 0) {
+    // Wait `msUntilTimeout` milliseconds before committing.
+    root.timeoutHandle = scheduleTimeout(
+      onTimeout.bind(null, root, finishedWork, suspendedExpirationTime),
+      msUntilTimeout
+    );
   }
-  root.expirationTime = expirationTime;
 }
 
 function onYield(root) {
   root.finishedWork = null;
 }
 
+function onTimeout(root, finishedWork, suspendedExpirationTime) {
+  if (enableSuspense) {
+    // The root timed out. Commit it.
+    root.pendingCommitExpirationTime = suspendedExpirationTime;
+    root.finishedWork = finishedWork;
+    // Read the current time before entering the commit phase. We can be
+    // certain this won't cause tearing related to batching of event updates
+    // because we're at the top of a timer event.
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+    flushRoot(root, suspendedExpirationTime);
+  }
+}
+
 function onCommit(root, expirationTime) {
   root.expirationTime = expirationTime;
   root.finishedWork = null;
 }
 
+function requestCurrentTime() {
+  // requestCurrentTime is called by the scheduler to compute an expiration
+  // time.
+  //
+  // Expiration times are computed by adding to the current time (the start
+  // time). However, if two updates are scheduled within the same event, we
+  // should treat their start times as simultaneous, even if the actual clock
+  // time has advanced between the first and second call.
+
+  // In other words, because expiration times determine how updates are batched,
+  // we want all updates of like priority that occur within the same event to
+  // receive the same expiration time. Otherwise we get tearing.
+  //
+  // We keep track of two separate times: the current "renderer" time and the
+  // current "scheduler" time. The renderer time can be updated whenever; it
+  // only exists to minimize the calls performance.now.
+  //
+  // But the scheduler time can only be updated if there's no pending work, or
+  // if we know for certain that we're not in the middle of an event.
+
+  if (isRendering) {
+    // We're already rendering. Return the most recently read time.
+    return currentSchedulerTime;
+  }
+  // Check if there's pending work.
+  findHighestPriorityRoot();
+  if (
+    nextFlushedExpirationTime === NoWork ||
+    nextFlushedExpirationTime === Never
+  ) {
+    // If there's no pending work, or if the pending work is offscreen, we can
+    // read the current time without risk of tearing.
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+    return currentSchedulerTime;
+  }
+  // There's already pending work. We might be in the middle of a browser
+  // event. If we were to read the current time, it could cause multiple updates
+  // within the same event to receive different expiration times, leading to
+  // tearing. Return the last read time. During the next idle callback, the
+  // time will be updated.
+  return currentSchedulerTime;
+}
+
 // requestWork is called by the scheduler whenever a root receives an update.
 // It's up to the renderer to call renderRoot at some point in the future.
 function requestWork(root, expirationTime) {
   addRootToSchedule(root, expirationTime);
-
   if (isRendering) {
     // Prevent reentrancy. Remaining work will be scheduled at the end of
     // the currently rendering batch.
@@ -13403,7 +14124,7 @@ function requestWork(root, expirationTime) {
       // flush it now.
       nextFlushedRoot = root;
       nextFlushedExpirationTime = Sync;
-      performWorkOnRoot(root, Sync, false);
+      performWorkOnRoot(root, Sync, true);
     }
     return;
   }
@@ -13502,19 +14223,6 @@ function findHighestPriorityRoot() {
     }
   }
 
-  // If the next root is the same as the previous root, this is a nested
-  // update. To prevent an infinite loop, increment the nested update count.
-  var previousFlushedRoot = nextFlushedRoot;
-  if (
-    previousFlushedRoot !== null &&
-    previousFlushedRoot === highestPriorityRoot &&
-    highestPriorityWork === Sync
-  ) {
-    nestedUpdateCount++;
-  } else {
-    // Reset whenever we switch roots.
-    nestedUpdateCount = 0;
-  }
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -13535,27 +14243,34 @@ function performWork(minExpirationTime, dl) {
   findHighestPriorityRoot();
 
   if (enableProfilerTimer) {
-    resumeActualRenderTimerIfPaused();
-  }
-
-  if (enableUserTimingAPI && deadline !== null) {
-    var didExpire = nextFlushedExpirationTime < recalculateCurrentTime();
-    var timeout = expirationTimeToMs(nextFlushedExpirationTime);
-    stopRequestCallbackTimer(didExpire, timeout);
+    resumeActualRenderTimerIfPaused(minExpirationTime === Sync);
   }
 
   if (deadline !== null) {
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+
+    if (enableUserTimingAPI) {
+      var didExpire = nextFlushedExpirationTime < currentRendererTime;
+      var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+      stopRequestCallbackTimer(didExpire, timeout);
+    }
+
     while (
       nextFlushedRoot !== null &&
       nextFlushedExpirationTime !== NoWork &&
       (minExpirationTime === NoWork ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime)
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime)
     ) {
-      recalculateCurrentTime();
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      );
       findHighestPriorityRoot();
+      recomputeCurrentRendererTime();
+      currentSchedulerTime = currentRendererTime;
     }
   } else {
     while (
@@ -13564,7 +14279,7 @@ function performWork(minExpirationTime, dl) {
       (minExpirationTime === NoWork ||
         minExpirationTime >= nextFlushedExpirationTime)
     ) {
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
       findHighestPriorityRoot();
     }
   }
@@ -13600,14 +14315,15 @@ function flushRoot(root, expirationTime) {
   // including the given time.
   nextFlushedRoot = root;
   nextFlushedExpirationTime = expirationTime;
-  performWorkOnRoot(root, expirationTime, false);
+  performWorkOnRoot(root, expirationTime, true);
   // Flush any sync work that was scheduled by lifecycles
   performSyncWork();
-  finishRendering();
+  pauseActualRenderTimerIfRunning();
 }
 
 function finishRendering() {
   nestedUpdateCount = 0;
+  lastCommittedRootDuringThisBatch = null;
 
   if (completedBatches !== null) {
     var batches = completedBatches;
@@ -13633,7 +14349,7 @@ function finishRendering() {
   }
 }
 
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused " +
@@ -13643,15 +14359,28 @@ function performWorkOnRoot(root, expirationTime, isYieldy) {
   isRendering = true;
 
   // Check if this is async work or sync/expired work.
-  if (!isYieldy) {
+  if (deadline === null || isExpired) {
     // Flush work without yielding.
+    // TODO: Non-yieldy work does not necessarily imply expired work. A renderer
+    // may want to perform some work without yielding, but also without
+    // requiring the root to complete (by triggering placeholders).
+
     var finishedWork = root.finishedWork;
     if (finishedWork !== null) {
       // This root is already complete. We can commit it.
       completeRoot$1(root, finishedWork, expirationTime);
     } else {
       root.finishedWork = null;
-      renderRoot(root, false);
+      // If this root previously suspended, clear its existing timeout, since
+      // we're about to try rendering again.
+      var timeoutHandle = root.timeoutHandle;
+      if (enableSuspense && timeoutHandle !== noTimeout) {
+        root.timeoutHandle = noTimeout;
+        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+        cancelTimeout(timeoutHandle);
+      }
+      var isYieldy = false;
+      renderRoot(root, isYieldy, isExpired);
       finishedWork = root.finishedWork;
       if (finishedWork !== null) {
         // We've completed the root. Commit it.
@@ -13666,7 +14395,16 @@ function performWorkOnRoot(root, expirationTime, isYieldy) {
       completeRoot$1(root, _finishedWork, expirationTime);
     } else {
       root.finishedWork = null;
-      renderRoot(root, true);
+      // If this root previously suspended, clear its existing timeout, since
+      // we're about to try rendering again.
+      var _timeoutHandle = root.timeoutHandle;
+      if (enableSuspense && _timeoutHandle !== noTimeout) {
+        root.timeoutHandle = noTimeout;
+        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+        cancelTimeout(_timeoutHandle);
+      }
+      var _isYieldy = true;
+      renderRoot(root, _isYieldy, isExpired);
       _finishedWork = root.finishedWork;
       if (_finishedWork !== null) {
         // We've completed the root. Check the deadline one more time
@@ -13712,16 +14450,31 @@ function completeRoot$1(root, finishedWork, expirationTime) {
 
   // Commit the root.
   root.finishedWork = null;
+
+  // Check if this is a nested update (a sync update scheduled during the
+  // commit phase).
+  if (root === lastCommittedRootDuringThisBatch) {
+    // If the next root is the same as the previous root, this is a nested
+    // update. To prevent an infinite loop, increment the nested update count.
+    nestedUpdateCount++;
+  } else {
+    // Reset whenever we switch roots.
+    lastCommittedRootDuringThisBatch = root;
+    nestedUpdateCount = 0;
+  }
   commitRoot(root, finishedWork);
 }
 
 // When working on async work, the reconciler asks the renderer if it should
 // yield execution. For DOM, we implement this with requestIdleCallback.
 function shouldYield() {
-  if (deadline === null || deadlineDidExpire) {
-    return false;
+  if (deadlineDidExpire) {
+    return true;
   }
-  if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+  if (
+    deadline === null ||
+    deadline.timeRemaining() > timeHeuristicForUnitOfWork
+  ) {
     // Disregard deadline.didTimeout. Only expired work should be flushed
     // during a timeout. This path is only hit for non-expired work.
     return false;
@@ -13856,7 +14609,7 @@ var didWarnAboutNestedUpdates = void 0;
 
 function getContextForSubtree(parentComponent) {
   if (!parentComponent) {
-    return emptyObject;
+    return emptyContextObject;
   }
 
   var fiber = get$1(parentComponent);
@@ -13866,21 +14619,17 @@ function getContextForSubtree(parentComponent) {
     : parentContext;
 }
 
-function scheduleRootUpdate(current, element, expirationTime, callback) {
+function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
   {
-    if (
-      ReactDebugCurrentFiber.phase === "render" &&
-      ReactDebugCurrentFiber.current !== null &&
-      !didWarnAboutNestedUpdates
-    ) {
+    if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
       didWarnAboutNestedUpdates = true;
-      warning(
+      warningWithoutStack$1(
         false,
         "Render methods should be a pure function of props and state; " +
           "triggering nested component updates from render is not allowed. " +
           "If necessary, trigger nested updates in componentDidUpdate.\n\n" +
           "Check the render method of %s.",
-        getComponentName(ReactDebugCurrentFiber.current) || "Unknown"
+        getComponentName(current.type) || "Unknown"
       );
     }
   }
@@ -13893,7 +14642,7 @@ function scheduleRootUpdate(current, element, expirationTime, callback) {
   callback = callback === undefined ? null : callback;
   if (callback !== null) {
     !(typeof callback === "function")
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "render(...): Expected the last optional `callback` argument to be a " +
             "function. Instead received: %s.",
@@ -13902,9 +14651,9 @@ function scheduleRootUpdate(current, element, expirationTime, callback) {
       : void 0;
     update.callback = callback;
   }
-  enqueueUpdate(current, update, expirationTime);
+  enqueueUpdate(current$$1, update);
 
-  scheduleWork(current, expirationTime);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 
@@ -13916,11 +14665,11 @@ function updateContainerAtExpirationTime(
   callback
 ) {
   // TODO: If this is a nested container, this won't be the root.
-  var current = container.current;
+  var current$$1 = container.current;
 
   {
     if (ReactFiberInstrumentation_1.debugTool) {
-      if (current.alternate === null) {
+      if (current$$1.alternate === null) {
         ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
       } else if (element === null) {
         ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
@@ -13937,7 +14686,7 @@ function updateContainerAtExpirationTime(
     container.pendingContext = context;
   }
 
-  return scheduleRootUpdate(current, element, expirationTime, callback);
+  return scheduleRootUpdate(current$$1, element, expirationTime, callback);
 }
 
 function findHostInstance$1(component) {
@@ -13965,9 +14714,9 @@ function createContainer(containerInfo, isAsync, hydrate) {
 }
 
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current;
-  var currentTime = recalculateCurrentTime();
-  var expirationTime = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current;
+  var currentTime = requestCurrentTime();
+  var expirationTime = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
@@ -14468,6 +15217,11 @@ function getInstanceFromTag(tag) {
 }
 
 // Module provided by RN:
+var emptyObject$2 = {};
+{
+  Object.freeze(emptyObject$2);
+}
+
 var getInspectorDataForViewTag = void 0;
 
 {
@@ -14498,9 +15252,9 @@ var getInspectorDataForViewTag = void 0;
   var getHostProps = function(fiber) {
     var host = findCurrentHostFiber(fiber);
     if (host) {
-      return host.memoizedProps || emptyObject;
+      return host.memoizedProps || emptyObject$2;
     }
-    return emptyObject;
+    return emptyObject$2;
   };
 
   var getHostNode = function(fiber, findNodeHandle) {
@@ -14522,7 +15276,7 @@ var getInspectorDataForViewTag = void 0;
   var createHierarchy = function(fiberHierarchy) {
     return fiberHierarchy.map(function(fiber) {
       return {
-        name: getComponentName(fiber),
+        name: getComponentName(fiber.type),
         getInspectorData: function(findNodeHandle) {
           return {
             measure: function(callback) {
@@ -14546,7 +15300,7 @@ var getInspectorDataForViewTag = void 0;
     if (!closestInstance) {
       return {
         hierarchy: [],
-        props: emptyObject,
+        props: emptyObject$2,
         selection: null,
         source: null
       };
@@ -14569,6 +15323,7 @@ var getInspectorDataForViewTag = void 0;
   };
 }
 
+var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 var findHostInstance = findHostInstance$1;
 
 function findNodeHandle(componentOrHandle) {
@@ -14576,14 +15331,14 @@ function findNodeHandle(componentOrHandle) {
     var owner = ReactCurrentOwner.current;
     if (owner !== null && owner.stateNode !== null) {
       !owner.stateNode._warnedAboutRefsInRender
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%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.",
-            getComponentName(owner) || "A component"
+            getComponentName(owner.type) || "A component"
           )
         : void 0;
 
diff --git a/Libraries/Renderer/oss/ReactFabric-prod.js b/Libraries/Renderer/oss/ReactFabric-prod.js
index b64b8908f..3b9bbfd03 100644
--- a/Libraries/Renderer/oss/ReactFabric-prod.js
+++ b/Libraries/Renderer/oss/ReactFabric-prod.js
@@ -12,16 +12,35 @@
 
 "use strict";
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant"),
-  ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
+var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
   UIManager = require("UIManager"),
   React = require("react"),
-  emptyObject = require("fbjs/lib/emptyObject"),
   deepDiffer = require("deepDiffer"),
   flattenStyle = require("flattenStyle"),
   TextInputState = require("TextInputState"),
   FabricUIManager = require("FabricUIManager"),
   ExceptionsManager = require("ExceptionsManager");
+function invariant(condition, format, a, b, c, d, e, f) {
+  if (!condition) {
+    condition = void 0;
+    if (void 0 === format)
+      condition = Error(
+        "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+      );
+    else {
+      var args = [a, b, c, d, e, f],
+        argIndex = 0;
+      condition = Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      condition.name = "Invariant Violation";
+    }
+    condition.framesToPop = 1;
+    throw condition;
+  }
+}
 function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = !1;
   this._caughtError = null;
@@ -347,9 +366,6 @@ function accumulateDirectDispatchesSingle(event) {
     }
   }
 }
-var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(
-  " "
-);
 function functionThatReturnsTrue() {
   return !0;
 }
@@ -407,12 +423,9 @@ Object.assign(SyntheticEvent.prototype, {
     var Interface = this.constructor.Interface,
       propName;
     for (propName in Interface) this[propName] = null;
-    for (
-      Interface = 0;
-      Interface < shouldBeReleasedProperties.length;
-      Interface++
-    )
-      this[shouldBeReleasedProperties[Interface]] = null;
+    this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+    this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+    this._dispatchInstances = this._dispatchListeners = null;
   }
 });
 SyntheticEvent.Interface = {
@@ -458,7 +471,7 @@ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
 function releasePooledEvent(event) {
   invariant(
     event instanceof this,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   10 > this.eventPool.length && this.eventPool.push(event);
@@ -615,7 +628,9 @@ function accumulate(current, next) {
     ? next
     : Array.isArray(current)
       ? current.concat(next)
-      : Array.isArray(next) ? [current].concat(next) : [current, next];
+      : Array.isArray(next)
+        ? [current].concat(next)
+        : [current, next];
 }
 var responderInst = null,
   trackedTouchCount = 0;
@@ -881,7 +896,9 @@ var eventTypes$1 = {
           ? eventTypes$1.responderStart
           : targetInst
             ? eventTypes$1.responderMove
-            : depthA ? eventTypes$1.responderEnd : null)
+            : depthA
+              ? eventTypes$1.responderEnd
+              : null)
       )
         (JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(
           JSCompiler_temp$jscomp$0,
@@ -935,7 +952,9 @@ var eventTypes$1 = {
       if (
         (topLevelType = JSCompiler_temp$jscomp$0
           ? eventTypes$1.responderTerminate
-          : topLevelType ? eventTypes$1.responderRelease : null)
+          : topLevelType
+            ? eventTypes$1.responderRelease
+            : null)
       )
         (nativeEvent = ResponderSyntheticEvent.getPooled(
           topLevelType,
@@ -1001,7 +1020,7 @@ injection.injectEventPluginsByName({
 function getInstanceFromInstance(instanceHandle) {
   return instanceHandle;
 }
-var Injected$jscomp$inline_574 = {
+var Injected$jscomp$inline_618 = {
   getClosestInstanceFromNode: getInstanceFromInstance,
   getInstanceFromNode: getInstanceFromInstance,
   getNodeFromInstance: function(inst) {
@@ -1014,9 +1033,9 @@ var Injected$jscomp$inline_574 = {
   }
 };
 getFiberCurrentPropsFromNode =
-  Injected$jscomp$inline_574.getFiberCurrentPropsFromNode;
-getInstanceFromNode = Injected$jscomp$inline_574.getInstanceFromNode;
-getNodeFromInstance = Injected$jscomp$inline_574.getNodeFromInstance;
+  Injected$jscomp$inline_618.getFiberCurrentPropsFromNode;
+getInstanceFromNode = Injected$jscomp$inline_618.getInstanceFromNode;
+getNodeFromInstance = Injected$jscomp$inline_618.getNodeFromInstance;
 ResponderEventPlugin.injection.injectGlobalResponderHandler({
   onChange: function(from, to, blockNativeResponder) {
     null !== to
@@ -1027,8 +1046,8 @@ ResponderEventPlugin.injection.injectGlobalResponderHandler({
       : UIManager.clearJSResponder();
   }
 });
-var ReactCurrentOwner =
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
+var ReactSharedInternals =
+    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
   hasSymbol = "function" === typeof Symbol && Symbol.for,
   REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103,
   REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106,
@@ -1039,7 +1058,7 @@ var ReactCurrentOwner =
   REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110,
   REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111,
   REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112,
-  REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 60113,
+  REACT_PLACEHOLDER_TYPE = hasSymbol ? Symbol.for("react.placeholder") : 60113,
   MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "undefined" === typeof maybeIterable)
@@ -1049,34 +1068,35 @@ function getIteratorFn(maybeIterable) {
     maybeIterable["@@iterator"];
   return "function" === typeof maybeIterable ? maybeIterable : null;
 }
-function getComponentName(fiber) {
-  var type = fiber.type;
-  if ("function" === typeof type) return type.displayName || type.name;
+function getComponentName(type) {
+  if (null == type) return null;
+  if ("function" === typeof type) return type.displayName || type.name || null;
   if ("string" === typeof type) return type;
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if ("object" === typeof type && null !== type)
+  if ("object" === typeof type)
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
         return (
-          (fiber = type.render.displayName || type.render.name || ""),
-          "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef"
+          (type = type.render),
+          (type = type.displayName || type.name || ""),
+          "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"
         );
     }
   return null;
@@ -1219,7 +1239,7 @@ function mountSafeCallback(context, callback) {
     }
   };
 }
-var emptyObject$1 = {},
+var emptyObject = {},
   removedKeys = null,
   removedKeyCount = 0;
 function restoreDeletedValuesInNestedArray(
@@ -1319,7 +1339,7 @@ function addNestedProperty(updatePayload, nextProp, validAttributes) {
   if (!Array.isArray(nextProp))
     return diffProperties(
       updatePayload,
-      emptyObject$1,
+      emptyObject,
       nextProp,
       validAttributes
     );
@@ -1337,7 +1357,7 @@ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
     return diffProperties(
       updatePayload,
       prevProp,
-      emptyObject$1,
+      emptyObject,
       validAttributes
     );
   for (var i = 0; i < prevProp.length; i++)
@@ -1570,7 +1590,7 @@ var ReactFabricHostComponent = (function() {
   ReactFabricHostComponent.prototype.setNativeProps = function(nativeProps) {
     nativeProps = diffProperties(
       null,
-      emptyObject$1,
+      emptyObject,
       nativeProps,
       this.viewConfig.validAttributes
     );
@@ -1605,7 +1625,7 @@ function createTextInstance(
     )
   };
 }
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   do {
     a: switch (workInProgress.tag) {
@@ -1613,11 +1633,12 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
       case 1:
       case 2:
       case 5:
+      case 11:
         var owner = workInProgress._debugOwner,
           source = workInProgress._debugSource;
-        var JSCompiler_inline_result = getComponentName(workInProgress);
+        var JSCompiler_inline_result = getComponentName(workInProgress.type);
         var ownerName = null;
-        owner && (ownerName = getComponentName(owner));
+        owner && (ownerName = getComponentName(owner.type));
         owner = source;
         JSCompiler_inline_result =
           "\n    in " +
@@ -1628,7 +1649,9 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
               ":" +
               owner.lineNumber +
               ")"
-            : ownerName ? " (created by " + ownerName + ")" : "");
+            : ownerName
+              ? " (created by " + ownerName + ")"
+              : "");
         break a;
       default:
         JSCompiler_inline_result = "";
@@ -1641,9 +1664,6 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
 new Set();
 var valueStack = [],
   index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
-}
 function pop(cursor) {
   0 > index ||
     ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
@@ -1653,9 +1673,10 @@ function push(cursor, value) {
   valueStack[index] = cursor.current;
   cursor.current = value;
 }
-var contextStackCursor = createCursor(emptyObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyObject;
+var emptyContextObject = {},
+  contextStackCursor = { current: emptyContextObject },
+  didPerformWorkStackCursor = { current: !1 },
+  previousContext = emptyContextObject;
 function getUnmaskedContext(workInProgress) {
   return isContextProvider(workInProgress)
     ? previousContext
@@ -1663,7 +1684,7 @@ function getUnmaskedContext(workInProgress) {
 }
 function getMaskedContext(workInProgress, unmaskedContext) {
   var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyObject;
+  if (!contextTypes) return emptyContextObject;
   var instance = workInProgress.stateNode;
   if (
     instance &&
@@ -1692,15 +1713,16 @@ function popTopLevelContextObject(fiber) {
 }
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "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(fiber, parentContext) {
-  var instance = fiber.stateNode,
-    childContextTypes = fiber.type.childContextTypes;
+  var instance = fiber.stateNode;
+  fiber = fiber.type;
+  var childContextTypes = fiber.childContextTypes;
   if ("function" !== typeof instance.getChildContext) return parentContext;
   instance = instance.getChildContext();
   for (var contextKey in instance)
@@ -1717,7 +1739,7 @@ function pushContextProvider(workInProgress) {
   var instance = workInProgress.stateNode;
   instance =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
   previousContext = contextStackCursor.current;
   push(contextStackCursor, instance, workInProgress);
   push(
@@ -1742,6 +1764,30 @@ function invalidateContextProvider(workInProgress, didChange) {
   } else pop(didPerformWorkStackCursor, workInProgress);
   push(didPerformWorkStackCursor, didChange, workInProgress);
 }
+var onCommitFiberRoot = null,
+  onCommitFiberUnmount = null;
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {}
+  };
+}
+function injectInternals(internals) {
+  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled || !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 FiberNode(tag, pendingProps, key, mode) {
   this.tag = tag;
   this.key = key;
@@ -1749,11 +1795,11 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.index = 0;
   this.ref = null;
   this.pendingProps = pendingProps;
-  this.memoizedState = this.updateQueue = this.memoizedProps = null;
+  this.firstContextDependency = this.memoizedState = this.updateQueue = this.memoizedProps = null;
   this.mode = mode;
   this.effectTag = 0;
   this.lastEffect = this.firstEffect = this.nextEffect = null;
-  this.expirationTime = 0;
+  this.childExpirationTime = this.expirationTime = 0;
   this.alternate = null;
 }
 function createWorkInProgress(current, pendingProps, expirationTime) {
@@ -1774,11 +1820,16 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
       (workInProgress.nextEffect = null),
       (workInProgress.firstEffect = null),
       (workInProgress.lastEffect = null));
-  workInProgress.expirationTime = expirationTime;
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  workInProgress.expirationTime =
+    pendingProps !== current.pendingProps
+      ? expirationTime
+      : current.expirationTime;
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
   workInProgress.sibling = current.sibling;
   workInProgress.index = current.index;
   workInProgress.ref = current.ref;
@@ -1815,15 +1866,14 @@ function createFiberFromElement(element, mode, expirationTime) {
           (type.expirationTime = expirationTime),
           type
         );
-      case REACT_TIMEOUT_TYPE:
+      case REACT_PLACEHOLDER_TYPE:
         fiberTag = 16;
-        mode |= 2;
         break;
       default:
         a: {
-          switch ("object" === typeof type && null !== type
-            ? type.$$typeof
-            : null) {
+          switch (
+            "object" === typeof type && null !== type ? type.$$typeof : null
+          ) {
             case REACT_PROVIDER_TYPE:
               fiberTag = 13;
               break a;
@@ -1888,6 +1938,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
     didError: !1,
     pendingCommitExpirationTime: 0,
     finishedWork: null,
+    timeoutHandle: -1,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -1898,36 +1949,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   };
   return (isAsync.stateNode = containerInfo);
 }
-var onCommitFiberRoot = null,
-  onCommitFiberUnmount = null;
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {}
-  };
-}
-function injectInternals(internals) {
-  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled || !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(root) {
-  "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
-}
-function onCommitUnmount(fiber) {
-  "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
-}
 function markPendingPriorityLevel(root, expirationTime) {
   root.didError = !1;
   var earliestPendingTime = root.earliestPendingTime;
@@ -1937,30 +1958,30 @@ function markPendingPriorityLevel(root, expirationTime) {
       ? (root.earliestPendingTime = expirationTime)
       : root.latestPendingTime < expirationTime &&
         (root.latestPendingTime = expirationTime);
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
-function findNextPendingPriorityLevel(root) {
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
   var earliestSuspendedTime = root.earliestSuspendedTime,
-    earliestPendingTime = root.earliestPendingTime;
-  if (0 === earliestSuspendedTime)
-    var nextExpirationTimeToWorkOn = (earliestSuspendedTime = earliestPendingTime);
-  else
-    0 !== earliestPendingTime
-      ? ((nextExpirationTimeToWorkOn = earliestPendingTime),
-        (earliestSuspendedTime =
-          earliestSuspendedTime < earliestPendingTime
-            ? earliestSuspendedTime
-            : earliestPendingTime))
-      : (nextExpirationTimeToWorkOn = earliestSuspendedTime =
-          root.latestPingedTime);
-  root.didError && (earliestSuspendedTime = 1);
-  root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
-  root.expirationTime = earliestSuspendedTime;
+    latestSuspendedTime = root.latestSuspendedTime,
+    earliestPendingTime = root.earliestPendingTime,
+    latestPingedTime = root.latestPingedTime;
+  earliestPendingTime =
+    0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+  0 === earliestPendingTime &&
+    (0 === completedExpirationTime ||
+      latestSuspendedTime > completedExpirationTime) &&
+    (earliestPendingTime = latestSuspendedTime);
+  completedExpirationTime = earliestPendingTime;
+  0 !== completedExpirationTime &&
+    0 !== earliestSuspendedTime &&
+    earliestSuspendedTime < completedExpirationTime &&
+    (completedExpirationTime = earliestSuspendedTime);
+  root.nextExpirationTimeToWorkOn = earliestPendingTime;
+  root.expirationTime = completedExpirationTime;
 }
 var hasForceUpdate = !1;
 function createUpdateQueue(baseState) {
   return {
-    expirationTime: 0,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -1974,7 +1995,6 @@ function createUpdateQueue(baseState) {
 }
 function cloneUpdateQueue(currentQueue) {
   return {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -1996,14 +2016,12 @@ function createUpdate(expirationTime) {
     nextEffect: null
   };
 }
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   null === queue.lastUpdate
     ? (queue.firstUpdate = queue.lastUpdate = update)
     : ((queue.lastUpdate.next = update), (queue.lastUpdate = update));
-  if (0 === queue.expirationTime || queue.expirationTime > expirationTime)
-    queue.expirationTime = expirationTime;
 }
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   var alternate = fiber.alternate;
   if (null === alternate) {
     var queue1 = fiber.updateQueue;
@@ -2025,14 +2043,13 @@ function enqueueUpdate(fiber, update, expirationTime) {
         : null === queue2 &&
           (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
   null === queue2 || queue1 === queue2
-    ? appendUpdateToQueue(queue1, update, expirationTime)
+    ? appendUpdateToQueue(queue1, update)
     : null === queue1.lastUpdate || null === queue2.lastUpdate
-      ? (appendUpdateToQueue(queue1, update, expirationTime),
-        appendUpdateToQueue(queue2, update, expirationTime))
-      : (appendUpdateToQueue(queue1, update, expirationTime),
-        (queue2.lastUpdate = update));
+      ? (appendUpdateToQueue(queue1, update),
+        appendUpdateToQueue(queue2, update))
+      : (appendUpdateToQueue(queue1, update), (queue2.lastUpdate = update));
 }
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   var workInProgressQueue = workInProgress.updateQueue;
   workInProgressQueue =
     null === workInProgressQueue
@@ -2044,11 +2061,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     ? (workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update)
     : ((workInProgressQueue.lastCapturedUpdate.next = update),
       (workInProgressQueue.lastCapturedUpdate = update));
-  if (
-    0 === workInProgressQueue.expirationTime ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  )
-    workInProgressQueue.expirationTime = renderExpirationTime;
 }
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
   var current = workInProgress.alternate;
@@ -2096,87 +2108,83 @@ function processUpdateQueue(
   renderExpirationTime
 ) {
   hasForceUpdate = !1;
-  if (
-    !(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)
-  ) {
-    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
-    for (
-      var newBaseState = queue.baseState,
-        newFirstUpdate = null,
-        newExpirationTime = 0,
-        update = queue.firstUpdate,
-        resultState = newBaseState;
-      null !== update;
+  queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+  for (
+    var newBaseState = queue.baseState,
+      newFirstUpdate = null,
+      newExpirationTime = 0,
+      update = queue.firstUpdate,
+      resultState = newBaseState;
+    null !== update;
 
-    ) {
-      var updateExpirationTime = update.expirationTime;
-      if (updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === newFirstUpdate &&
-            ((newFirstUpdate = update), (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > updateExpirationTime)
-        )
-          newExpirationTime = updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastEffect
-              ? (queue.firstEffect = queue.lastEffect = update)
-              : ((queue.lastEffect.nextEffect = update),
-                (queue.lastEffect = update)));
-      update = update.next;
-    }
-    updateExpirationTime = null;
-    for (update = queue.firstCapturedUpdate; null !== update; ) {
-      var _updateExpirationTime = update.expirationTime;
-      if (_updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === updateExpirationTime &&
-            ((updateExpirationTime = update),
-            null === newFirstUpdate && (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
-        )
-          newExpirationTime = _updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastCapturedEffect
-              ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
-              : ((queue.lastCapturedEffect.nextEffect = update),
-                (queue.lastCapturedEffect = update)));
-      update = update.next;
-    }
-    null === newFirstUpdate && (queue.lastUpdate = null);
-    null === updateExpirationTime
-      ? (queue.lastCapturedUpdate = null)
-      : (workInProgress.effectTag |= 32);
-    null === newFirstUpdate &&
-      null === updateExpirationTime &&
-      (newBaseState = resultState);
-    queue.baseState = newBaseState;
-    queue.firstUpdate = newFirstUpdate;
-    queue.firstCapturedUpdate = updateExpirationTime;
-    queue.expirationTime = newExpirationTime;
-    workInProgress.memoizedState = resultState;
+  ) {
+    var updateExpirationTime = update.expirationTime;
+    if (updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === newFirstUpdate &&
+          ((newFirstUpdate = update), (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > updateExpirationTime)
+      )
+        newExpirationTime = updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastEffect
+            ? (queue.firstEffect = queue.lastEffect = update)
+            : ((queue.lastEffect.nextEffect = update),
+              (queue.lastEffect = update)));
+    update = update.next;
   }
+  updateExpirationTime = null;
+  for (update = queue.firstCapturedUpdate; null !== update; ) {
+    var _updateExpirationTime = update.expirationTime;
+    if (_updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === updateExpirationTime &&
+          ((updateExpirationTime = update),
+          null === newFirstUpdate && (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
+      )
+        newExpirationTime = _updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastCapturedEffect
+            ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
+            : ((queue.lastCapturedEffect.nextEffect = update),
+              (queue.lastCapturedEffect = update)));
+    update = update.next;
+  }
+  null === newFirstUpdate && (queue.lastUpdate = null);
+  null === updateExpirationTime
+    ? (queue.lastCapturedUpdate = null)
+    : (workInProgress.effectTag |= 32);
+  null === newFirstUpdate &&
+    null === updateExpirationTime &&
+    (newBaseState = resultState);
+  queue.baseState = newBaseState;
+  queue.firstUpdate = newFirstUpdate;
+  queue.firstCapturedUpdate = updateExpirationTime;
+  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.memoizedState = resultState;
 }
 function callCallback(callback, context) {
   invariant(
@@ -2218,34 +2226,153 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
-var providerCursor = createCursor(null),
-  valueCursor = createCursor(null),
-  changedBitsCursor = createCursor(0);
+var valueCursor = { current: null },
+  changedBitsCursor = { current: 0 },
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastContextWithAllBitsObserved = null;
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
   push(changedBitsCursor, context._changedBits2, providerFiber);
   push(valueCursor, context._currentValue2, providerFiber);
-  push(providerCursor, providerFiber, providerFiber);
   context._currentValue2 = providerFiber.pendingProps.value;
   context._changedBits2 = providerFiber.stateNode;
 }
 function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current,
     currentValue = valueCursor.current;
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
   providerFiber = providerFiber.type._context;
   providerFiber._currentValue2 = currentValue;
   providerFiber._changedBits2 = changedBits;
 }
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  null !== fiber && (fiber.return = workInProgress);
+  for (; null !== fiber; ) {
+    var dependency = fiber.firstContextDependency;
+    if (null !== dependency) {
+      do {
+        if (
+          dependency.context === context &&
+          0 !== (dependency.observedBits & changedBits)
+        ) {
+          if (
+            0 === fiber.expirationTime ||
+            fiber.expirationTime > renderExpirationTime
+          )
+            fiber.expirationTime = renderExpirationTime;
+          var nextFiber = fiber.alternate;
+          null !== nextFiber &&
+            (0 === nextFiber.expirationTime ||
+              nextFiber.expirationTime > renderExpirationTime) &&
+            (nextFiber.expirationTime = renderExpirationTime);
+          for (var node = fiber.return; null !== node; ) {
+            nextFiber = node.alternate;
+            if (
+              0 === node.childExpirationTime ||
+              node.childExpirationTime > renderExpirationTime
+            )
+              (node.childExpirationTime = renderExpirationTime),
+                null !== nextFiber &&
+                  (0 === nextFiber.childExpirationTime ||
+                    nextFiber.childExpirationTime > renderExpirationTime) &&
+                  (nextFiber.childExpirationTime = renderExpirationTime);
+            else if (
+              null !== nextFiber &&
+              (0 === nextFiber.childExpirationTime ||
+                nextFiber.childExpirationTime > renderExpirationTime)
+            )
+              nextFiber.childExpirationTime = renderExpirationTime;
+            else break;
+            node = node.return;
+          }
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        dependency = dependency.next;
+      } while (null !== dependency);
+    } else
+      nextFiber =
+        13 === fiber.tag
+          ? fiber.type === workInProgress.type
+            ? null
+            : fiber.child
+          : fiber.child;
+    if (null !== nextFiber) nextFiber.return = fiber;
+    else
+      for (nextFiber = fiber; null !== nextFiber; ) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+    fiber = nextFiber;
+  }
+}
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextWithAllBitsObserved = lastContextDependency = null;
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (null !== firstContextDependency) {
+    workInProgress.firstContextDependency = null;
+    var hasPendingContext = !1;
+    do {
+      var _context = firstContextDependency.context,
+        changedBits = _context._changedBits2;
+      0 !== changedBits &&
+        (propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        ),
+        0 !== (changedBits & firstContextDependency.observedBits) &&
+          (hasPendingContext = !0));
+      firstContextDependency = firstContextDependency.next;
+    } while (null !== firstContextDependency);
+    return hasPendingContext;
+  }
+  return !1;
+}
+function readContext(context, observedBits) {
+  if (
+    lastContextWithAllBitsObserved !== context &&
+    !1 !== observedBits &&
+    0 !== observedBits
+  ) {
+    if ("number" !== typeof observedBits || 1073741823 === observedBits)
+      (lastContextWithAllBitsObserved = context), (observedBits = 1073741823);
+    observedBits = { context: context, observedBits: observedBits, next: null };
+    null === lastContextDependency
+      ? (invariant(
+          null !== currentlyRenderingFiber,
+          "Context.unstable_read(): Context can only be read while React is rendering, e.g. inside the render method or getDerivedStateFromProps."
+        ),
+        (currentlyRenderingFiber.firstContextDependency = lastContextDependency = observedBits))
+      : (lastContextDependency = lastContextDependency.next = observedBits);
+  }
+  return context._currentValue2;
+}
 var NO_CONTEXT = {},
-  contextStackCursor$1 = createCursor(NO_CONTEXT),
-  contextFiberStackCursor = createCursor(NO_CONTEXT),
-  rootInstanceStackCursor = createCursor(NO_CONTEXT);
+  contextStackCursor$1 = { current: NO_CONTEXT },
+  contextFiberStackCursor = { current: NO_CONTEXT },
+  rootInstanceStackCursor = { current: NO_CONTEXT };
 function requiredContext(c) {
   invariant(
     c !== NO_CONTEXT,
@@ -2265,6 +2392,24 @@ function popHostContainer(fiber) {
   pop(contextFiberStackCursor, fiber);
   pop(rootInstanceStackCursor, fiber);
 }
+function pushHostContext(fiber) {
+  requiredContext(rootInstanceStackCursor.current);
+  var context = requiredContext(contextStackCursor$1.current);
+  var nextContext = fiber.type;
+  nextContext =
+    "AndroidTextInput" === nextContext ||
+    "RCTMultilineTextInputView" === nextContext ||
+    "RCTSinglelineTextInputView" === nextContext ||
+    "RCTText" === nextContext ||
+    "RCTVirtualText" === nextContext;
+  nextContext =
+    context.isInAParentText !== nextContext
+      ? { isInAParentText: nextContext }
+      : context;
+  context !== nextContext &&
+    (push(contextFiberStackCursor, fiber, fiber),
+    push(contextStackCursor$1, nextContext, fiber));
+}
 function popHostContext(fiber) {
   contextFiberStackCursor.current === fiber &&
     (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
@@ -2293,6 +2438,7 @@ function shallowEqual(objA, objB) {
       return !1;
   return !0;
 }
+var emptyRefsObject = new React.Component().refs;
 function applyDerivedStateFromProps(
   workInProgress,
   getDerivedStateFromProps,
@@ -2305,10 +2451,10 @@ function applyDerivedStateFromProps(
       ? prevState
       : Object.assign({}, prevState, getDerivedStateFromProps);
   workInProgress.memoizedState = prevState;
-  workInProgress = workInProgress.updateQueue;
-  null !== workInProgress &&
+  getDerivedStateFromProps = workInProgress.updateQueue;
+  null !== getDerivedStateFromProps &&
     0 === workInProgress.expirationTime &&
-    (workInProgress.baseState = prevState);
+    (getDerivedStateFromProps.baseState = prevState);
 }
 var classComponentUpdater = {
   isMounted: function(component) {
@@ -2318,33 +2464,33 @@ var classComponentUpdater = {
   },
   enqueueSetState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 1;
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 2;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   }
 };
@@ -2354,12 +2500,12 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   workInProgress = workInProgress.type;
   return "function" === typeof instance.shouldComponentUpdate
-    ? instance.shouldComponentUpdate(newProps, newState, newContext)
+    ? instance.shouldComponentUpdate(newProps, newState, nextLegacyContext)
     : workInProgress.prototype && workInProgress.prototype.isPureReactComponent
       ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
       : !0;
@@ -2368,13 +2514,13 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   workInProgress = instance.state;
   "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   instance.state !== workInProgress &&
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
@@ -2385,7 +2531,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     unmaskedContext = getUnmaskedContext(workInProgress);
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
   unmaskedContext = workInProgress.updateQueue;
   null !== unmaskedContext &&
@@ -2397,7 +2543,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
       renderExpirationTime
     ),
     (instance.state = workInProgress.memoizedState));
-  unmaskedContext = workInProgress.type.getDerivedStateFromProps;
+  unmaskedContext = ctor.getDerivedStateFromProps;
   "function" === typeof unmaskedContext &&
     (applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
     (instance.state = workInProgress.memoizedState));
@@ -2426,7 +2572,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     (workInProgress.effectTag |= 4);
 }
 var isArray$1 = Array.isArray;
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   returnFiber = element.ref;
   if (
     null !== returnFiber &&
@@ -2449,18 +2595,19 @@ function coerceRef(returnFiber, current, element) {
       );
       var stringRef = "" + returnFiber;
       if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
+        null !== current$$1 &&
+        null !== current$$1.ref &&
+        "function" === typeof current$$1.ref &&
+        current$$1.ref._stringRef === stringRef
       )
-        return current.ref;
-      current = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        return current$$1.ref;
+      current$$1 = function(value) {
+        var refs = inst.refs;
+        refs === emptyRefsObject && (refs = inst.refs = {});
         null === value ? delete refs[stringRef] : (refs[stringRef] = value);
       };
-      current._stringRef = stringRef;
-      return current;
+      current$$1._stringRef = stringRef;
+      return current$$1;
     }
     invariant(
       "string" === typeof returnFiber,
@@ -2538,26 +2685,31 @@ function ChildReconciler(shouldTrackSideEffects) {
       (newFiber.effectTag = 2);
     return newFiber;
   }
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (null === current || 6 !== current.tag)
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (null === current$$1 || 6 !== current$$1.tag)
       return (
-        (current = createFiberFromText(
+        (current$$1 = createFiberFromText(
           textContent,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, textContent, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, textContent, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (null !== current && current.type === element.type)
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (null !== current$$1 && current$$1.type === element.type)
       return (
-        (expirationTime = useFiber(current, element.props, expirationTime)),
-        (expirationTime.ref = coerceRef(returnFiber, current, element)),
+        (expirationTime = useFiber(current$$1, element.props, expirationTime)),
+        (expirationTime.ref = coerceRef(returnFiber, current$$1, element)),
         (expirationTime.return = returnFiber),
         expirationTime
       );
@@ -2566,45 +2718,51 @@ function ChildReconciler(shouldTrackSideEffects) {
       returnFiber.mode,
       expirationTime
     );
-    expirationTime.ref = coerceRef(returnFiber, current, element);
+    expirationTime.ref = coerceRef(returnFiber, current$$1, element);
     expirationTime.return = returnFiber;
     return expirationTime;
   }
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      null === current$$1 ||
+      4 !== current$$1.tag ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     )
       return (
-        (current = createFiberFromPortal(
+        (current$$1 = createFiberFromPortal(
           portal,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, portal.children || [], expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (null === current || 10 !== current.tag)
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (null === current$$1 || 10 !== current$$1.tag)
       return (
-        (current = createFiberFromFragment(
+        (current$$1 = createFiberFromFragment(
           fragment,
           returnFiber.mode,
           expirationTime,
           key
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, fragment, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, fragment, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
   function createChild(returnFiber, newChild, expirationTime) {
     if ("string" === typeof newChild || "number" === typeof newChild)
@@ -3170,22 +3328,15 @@ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
         (hydrationParentFiber = fiber$jscomp$0);
   }
 }
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-function reconcileChildrenAtExpirationTime(
-  current,
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
   workInProgress.child =
-    null === current
+    null === current$$1
       ? mountChildFibers(
           workInProgress,
           null,
@@ -3194,47 +3345,47 @@ function reconcileChildrenAtExpirationTime(
         )
       : reconcileChildFibers(
           workInProgress,
-          current.child,
+          current$$1.child,
           nextChildren,
           renderExpirationTime
         );
 }
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
+    (null === current$$1 && null !== ref) ||
+    (null !== current$$1 && current$$1.ref !== ref)
   )
     workInProgress.effectTag |= 128;
 }
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
   var didCaptureError = 0 !== (workInProgress.effectTag & 64);
   if (!shouldUpdate && !didCaptureError)
     return (
       hasContext && invalidateContextProvider(workInProgress, !1),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
+      bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      )
     );
   shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   var nextChildren = didCaptureError ? null : shouldUpdate.render();
   workInProgress.effectTag |= 1;
-  didCaptureError &&
-    (reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    ),
+  null !== current$$1 &&
+    didCaptureError &&
+    (reconcileChildren(current$$1, workInProgress, null, renderExpirationTime),
     (workInProgress.child = null));
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -3256,164 +3407,57 @@ function pushHostRootContext(workInProgress) {
       pushTopLevelContextObject(workInProgress, root.context, !1);
   pushHostContainer(workInProgress, root.containerInfo);
 }
-function propagateContextChange(
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  null !== fiber && (fiber.return = workInProgress);
-  for (; null !== fiber; ) {
-    switch (fiber.tag) {
-      case 12:
-        var nextFiber = fiber.stateNode | 0;
-        if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
-          for (nextFiber = fiber; null !== nextFiber; ) {
-            var alternate = nextFiber.alternate;
-            if (
-              0 === nextFiber.expirationTime ||
-              nextFiber.expirationTime > renderExpirationTime
-            )
-              (nextFiber.expirationTime = renderExpirationTime),
-                null !== alternate &&
-                  (0 === alternate.expirationTime ||
-                    alternate.expirationTime > renderExpirationTime) &&
-                  (alternate.expirationTime = renderExpirationTime);
-            else if (
-              null !== alternate &&
-              (0 === alternate.expirationTime ||
-                alternate.expirationTime > renderExpirationTime)
-            )
-              alternate.expirationTime = renderExpirationTime;
-            else break;
-            nextFiber = nextFiber.return;
-          }
-          nextFiber = null;
-        } else nextFiber = fiber.child;
-        break;
-      case 13:
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        nextFiber = fiber.child;
-    }
-    if (null !== nextFiber) nextFiber.return = fiber;
-    else
-      for (nextFiber = fiber; null !== nextFiber; ) {
-        if (nextFiber === workInProgress) {
-          nextFiber = null;
-          break;
-        }
-        fiber = nextFiber.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
-        }
-        nextFiber = nextFiber.return;
-      }
-    fiber = nextFiber;
-  }
-}
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
-  var context = workInProgress.type._context,
-    newProps = workInProgress.pendingProps,
-    oldProps = workInProgress.memoizedProps,
-    canBailOnProps = !0;
-  if (didPerformWorkStackCursor.current) canBailOnProps = !1;
-  else if (oldProps === newProps)
-    return (
-      (workInProgress.stateNode = 0),
-      pushProvider(workInProgress),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
-    );
-  var newValue = newProps.value;
-  workInProgress.memoizedProps = newProps;
-  if (null === oldProps) newValue = 1073741823;
-  else if (oldProps.value === newProps.value) {
-    if (oldProps.children === newProps.children && canBailOnProps)
-      return (
-        (workInProgress.stateNode = 0),
-        pushProvider(workInProgress),
-        bailoutOnAlreadyFinishedWork(current, workInProgress)
-      );
-    newValue = 0;
-  } else {
-    var oldValue = oldProps.value;
-    if (
-      (oldValue === newValue &&
-        (0 !== oldValue || 1 / oldValue === 1 / newValue)) ||
-      (oldValue !== oldValue && newValue !== newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-      newValue = 0;
-    } else if (
-      ((newValue =
-        "function" === typeof context._calculateChangedBits
-          ? context._calculateChangedBits(oldValue, newValue)
-          : 1073741823),
-      (newValue |= 0),
-      0 === newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-    } else
-      propagateContextChange(
-        workInProgress,
-        context,
-        newValue,
-        renderExpirationTime
-      );
-  }
-  workInProgress.stateNode = newValue;
-  pushProvider(workInProgress);
-  reconcileChildren(current, workInProgress, newProps.children);
-  return workInProgress.child;
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+  null !== current$$1 &&
+    (workInProgress.firstContextDependency = current$$1.firstContextDependency);
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (0 === childExpirationTime || childExpirationTime > renderExpirationTime)
+    return null;
   invariant(
-    null === current || workInProgress.child === current.child,
+    null === current$$1 || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
   if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    var newChild = createWorkInProgress(
-      current,
-      current.pendingProps,
-      current.expirationTime
+    current$$1 = workInProgress.child;
+    renderExpirationTime = createWorkInProgress(
+      current$$1,
+      current$$1.pendingProps,
+      current$$1.expirationTime
     );
-    workInProgress.child = newChild;
-    for (newChild.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (newChild = newChild.sibling = createWorkInProgress(
-          current,
-          current.pendingProps,
-          current.expirationTime
+    workInProgress.child = renderExpirationTime;
+    for (
+      renderExpirationTime.return = workInProgress;
+      null !== current$$1.sibling;
+
+    )
+      (current$$1 = current$$1.sibling),
+        (renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(
+          current$$1,
+          current$$1.pendingProps,
+          current$$1.expirationTime
         )),
-        (newChild.return = workInProgress);
-    newChild.sibling = null;
+        (renderExpirationTime.return = workInProgress);
+    renderExpirationTime.sibling = null;
   }
   return workInProgress.child;
 }
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    0 === workInProgress.expirationTime ||
-    workInProgress.expirationTime > renderExpirationTime
+    !didPerformWorkStackCursor.current &&
+    (0 === updateExpirationTime || updateExpirationTime > renderExpirationTime)
   ) {
     switch (workInProgress.tag) {
       case 3:
         pushHostRootContext(workInProgress);
         break;
+      case 5:
+        pushHostContext(workInProgress);
+        break;
       case 2:
         pushContextProvider(workInProgress);
         break;
@@ -3424,21 +3468,27 @@ function beginWork(current, workInProgress, renderExpirationTime) {
         );
         break;
       case 13:
-        pushProvider(workInProgress);
+        (workInProgress.stateNode = 0), pushProvider(workInProgress);
     }
-    return null;
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
+  workInProgress.expirationTime = 0;
   switch (workInProgress.tag) {
     case 0:
       invariant(
-        null === current,
+        null === current$$1,
         "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue."
       );
-      var fn = workInProgress.type,
-        props = workInProgress.pendingProps,
-        unmaskedContext = getUnmaskedContext(workInProgress);
+      var fn = workInProgress.type;
+      updateExpirationTime = workInProgress.pendingProps;
+      var unmaskedContext = getUnmaskedContext(workInProgress);
       unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
-      fn = fn(props, unmaskedContext);
+      prepareToReadContext(workInProgress, renderExpirationTime);
+      fn = fn(updateExpirationTime, unmaskedContext);
       workInProgress.effectTag |= 1;
       "object" === typeof fn &&
       null !== fn &&
@@ -3450,45 +3500,52 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null !== fn.state && void 0 !== fn.state ? fn.state : null),
           (unmaskedContext = unmaskedContext.getDerivedStateFromProps),
           "function" === typeof unmaskedContext &&
-            applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
-          (props = pushContextProvider(workInProgress)),
+            applyDerivedStateFromProps(
+              workInProgress,
+              unmaskedContext,
+              updateExpirationTime
+            ),
+          (updateExpirationTime = pushContextProvider(workInProgress)),
           (fn.updater = classComponentUpdater),
           (workInProgress.stateNode = fn),
           (fn._reactInternalFiber = workInProgress),
           mountClassInstance(workInProgress, renderExpirationTime),
-          (current = finishClassComponent(
-            current,
+          (current$$1 = finishClassComponent(
+            current$$1,
             workInProgress,
             !0,
-            props,
+            updateExpirationTime,
             renderExpirationTime
           )))
         : ((workInProgress.tag = 1),
-          reconcileChildren(current, workInProgress, fn),
-          (workInProgress.memoizedProps = props),
-          (current = workInProgress.child));
-      return current;
+          reconcileChildren(
+            current$$1,
+            workInProgress,
+            fn,
+            renderExpirationTime
+          ),
+          (workInProgress.memoizedProps = updateExpirationTime),
+          (current$$1 = workInProgress.child));
+      return current$$1;
     case 1:
       return (
-        (props = workInProgress.type),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? ((fn = getUnmaskedContext(workInProgress)),
-            (fn = getMaskedContext(workInProgress, fn)),
-            (props = props(renderExpirationTime, fn)),
-            (workInProgress.effectTag |= 1),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (fn = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = getUnmaskedContext(workInProgress)),
+        (unmaskedContext = getMaskedContext(workInProgress, unmaskedContext)),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (fn = fn(updateExpirationTime, unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 2:
-      props = pushContextProvider(workInProgress);
-      if (null === current)
+      updateExpirationTime = pushContextProvider(workInProgress);
+      fn = prepareToReadContext(workInProgress, renderExpirationTime);
+      if (null === current$$1)
         if (null === workInProgress.stateNode) {
-          var props$jscomp$0 = workInProgress.pendingProps,
+          var props = workInProgress.pendingProps,
             ctor = workInProgress.type;
           fn = getUnmaskedContext(workInProgress);
           var needsContext =
@@ -3496,15 +3553,13 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null != workInProgress.type.contextTypes;
           unmaskedContext = needsContext
             ? getMaskedContext(workInProgress, fn)
-            : emptyObject;
-          props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
+            : emptyContextObject;
+          props = new ctor(props, unmaskedContext);
           workInProgress.memoizedState =
-            null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state
-              ? props$jscomp$0.state
-              : null;
-          props$jscomp$0.updater = classComponentUpdater;
-          workInProgress.stateNode = props$jscomp$0;
-          props$jscomp$0._reactInternalFiber = workInProgress;
+            null !== props.state && void 0 !== props.state ? props.state : null;
+          props.updater = classComponentUpdater;
+          workInProgress.stateNode = props;
+          props._reactInternalFiber = workInProgress;
           needsContext &&
             ((needsContext = workInProgress.stateNode),
             (needsContext.__reactInternalMemoizedUnmaskedChildContext = fn),
@@ -3512,122 +3567,46 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           mountClassInstance(workInProgress, renderExpirationTime);
           fn = !0;
         } else {
-          ctor = workInProgress.type;
-          fn = workInProgress.stateNode;
-          needsContext = workInProgress.memoizedProps;
-          unmaskedContext = workInProgress.pendingProps;
-          fn.props = needsContext;
-          var oldContext = fn.context;
-          props$jscomp$0 = getUnmaskedContext(workInProgress);
-          props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
-          var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-          (ctor =
+          var ctor$jscomp$0 = workInProgress.type;
+          unmaskedContext = workInProgress.stateNode;
+          props = workInProgress.memoizedProps;
+          needsContext = workInProgress.pendingProps;
+          unmaskedContext.props = props;
+          var oldContext = unmaskedContext.context;
+          ctor = getUnmaskedContext(workInProgress);
+          ctor = getMaskedContext(workInProgress, ctor);
+          var getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps;
+          (ctor$jscomp$0 =
             "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((needsContext !== unmaskedContext ||
-              oldContext !== props$jscomp$0) &&
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((props !== needsContext || oldContext !== ctor) &&
               callComponentWillReceiveProps(
                 workInProgress,
-                fn,
                 unmaskedContext,
-                props$jscomp$0
+                needsContext,
+                ctor
               ));
           hasForceUpdate = !1;
           var oldState = workInProgress.memoizedState;
-          oldContext = fn.state = oldState;
+          oldContext = unmaskedContext.state = oldState;
           var updateQueue = workInProgress.updateQueue;
           null !== updateQueue &&
             (processUpdateQueue(
               workInProgress,
               updateQueue,
+              needsContext,
               unmaskedContext,
-              fn,
               renderExpirationTime
             ),
             (oldContext = workInProgress.memoizedState));
-          needsContext !== unmaskedContext ||
+          props !== needsContext ||
           oldState !== oldContext ||
           didPerformWorkStackCursor.current ||
-          hasForceUpdate
-            ? ("function" === typeof getDerivedStateFromProps &&
-                (applyDerivedStateFromProps(
-                  workInProgress,
-                  getDerivedStateFromProps,
-                  unmaskedContext
-                ),
-                (oldContext = workInProgress.memoizedState)),
-              (needsContext =
-                hasForceUpdate ||
-                checkShouldComponentUpdate(
-                  workInProgress,
-                  needsContext,
-                  unmaskedContext,
-                  oldState,
-                  oldContext,
-                  props$jscomp$0
-                ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillMount &&
-                      "function" !== typeof fn.componentWillMount) ||
-                    ("function" === typeof fn.componentWillMount &&
-                      fn.componentWillMount(),
-                    "function" === typeof fn.UNSAFE_componentWillMount &&
-                      fn.UNSAFE_componentWillMount()),
-                  "function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4))
-                : ("function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4),
-                  (workInProgress.memoizedProps = unmaskedContext),
-                  (workInProgress.memoizedState = oldContext)),
-              (fn.props = unmaskedContext),
-              (fn.state = oldContext),
-              (fn.context = props$jscomp$0),
-              (fn = needsContext))
-            : ("function" === typeof fn.componentDidMount &&
-                (workInProgress.effectTag |= 4),
-              (fn = !1));
-        }
-      else
-        (ctor = workInProgress.type),
-          (fn = workInProgress.stateNode),
-          (unmaskedContext = workInProgress.memoizedProps),
-          (needsContext = workInProgress.pendingProps),
-          (fn.props = unmaskedContext),
-          (oldContext = fn.context),
-          (props$jscomp$0 = getUnmaskedContext(workInProgress)),
-          (props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0)),
-          (getDerivedStateFromProps = ctor.getDerivedStateFromProps),
-          (ctor =
-            "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((unmaskedContext !== needsContext ||
-              oldContext !== props$jscomp$0) &&
-              callComponentWillReceiveProps(
-                workInProgress,
-                fn,
-                needsContext,
-                props$jscomp$0
-              )),
-          (hasForceUpdate = !1),
-          (oldContext = workInProgress.memoizedState),
-          (oldState = fn.state = oldContext),
-          (updateQueue = workInProgress.updateQueue),
-          null !== updateQueue &&
-            (processUpdateQueue(
-              workInProgress,
-              updateQueue,
-              needsContext,
-              fn,
-              renderExpirationTime
-            ),
-            (oldState = workInProgress.memoizedState)),
-          unmaskedContext !== needsContext ||
-          oldContext !== oldState ||
-          didPerformWorkStackCursor.current ||
+          fn ||
           hasForceUpdate
             ? ("function" === typeof getDerivedStateFromProps &&
                 (applyDerivedStateFromProps(
@@ -3635,128 +3614,203 @@ function beginWork(current, workInProgress, renderExpirationTime) {
                   getDerivedStateFromProps,
                   needsContext
                 ),
-                (oldState = workInProgress.memoizedState)),
-              (getDerivedStateFromProps =
+                (oldContext = workInProgress.memoizedState)),
+              (fn =
                 hasForceUpdate ||
+                fn ||
                 checkShouldComponentUpdate(
                   workInProgress,
-                  unmaskedContext,
+                  props,
                   needsContext,
+                  oldState,
+                  oldContext,
+                  ctor
+                ))
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillMount) ||
+                    ("function" === typeof unmaskedContext.componentWillMount &&
+                      unmaskedContext.componentWillMount(),
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      unmaskedContext.UNSAFE_componentWillMount()),
+                  "function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4))
+                : ("function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4),
+                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedState = oldContext)),
+              (unmaskedContext.props = needsContext),
+              (unmaskedContext.state = oldContext),
+              (unmaskedContext.context = ctor))
+            : ("function" === typeof unmaskedContext.componentDidMount &&
+                (workInProgress.effectTag |= 4),
+              (fn = !1));
+        }
+      else
+        (ctor$jscomp$0 = workInProgress.type),
+          (unmaskedContext = workInProgress.stateNode),
+          (needsContext = workInProgress.memoizedProps),
+          (props = workInProgress.pendingProps),
+          (unmaskedContext.props = needsContext),
+          (oldContext = unmaskedContext.context),
+          (ctor = getUnmaskedContext(workInProgress)),
+          (ctor = getMaskedContext(workInProgress, ctor)),
+          (getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps),
+          (ctor$jscomp$0 =
+            "function" === typeof getDerivedStateFromProps ||
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((needsContext !== props || oldContext !== ctor) &&
+              callComponentWillReceiveProps(
+                workInProgress,
+                unmaskedContext,
+                props,
+                ctor
+              )),
+          (hasForceUpdate = !1),
+          (oldContext = workInProgress.memoizedState),
+          (oldState = unmaskedContext.state = oldContext),
+          (updateQueue = workInProgress.updateQueue),
+          null !== updateQueue &&
+            (processUpdateQueue(
+              workInProgress,
+              updateQueue,
+              props,
+              unmaskedContext,
+              renderExpirationTime
+            ),
+            (oldState = workInProgress.memoizedState)),
+          needsContext !== props ||
+          oldContext !== oldState ||
+          didPerformWorkStackCursor.current ||
+          fn ||
+          hasForceUpdate
+            ? ("function" === typeof getDerivedStateFromProps &&
+                (applyDerivedStateFromProps(
+                  workInProgress,
+                  getDerivedStateFromProps,
+                  props
+                ),
+                (oldState = workInProgress.memoizedState)),
+              (fn =
+                hasForceUpdate ||
+                fn ||
+                checkShouldComponentUpdate(
+                  workInProgress,
+                  needsContext,
+                  props,
                   oldContext,
                   oldState,
-                  props$jscomp$0
+                  ctor
                 ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillUpdate &&
-                      "function" !== typeof fn.componentWillUpdate) ||
-                    ("function" === typeof fn.componentWillUpdate &&
-                      fn.componentWillUpdate(
-                        needsContext,
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillUpdate) ||
+                    ("function" ===
+                      typeof unmaskedContext.componentWillUpdate &&
+                      unmaskedContext.componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       ),
-                    "function" === typeof fn.UNSAFE_componentWillUpdate &&
-                      fn.UNSAFE_componentWillUpdate(
-                        needsContext,
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      unmaskedContext.UNSAFE_componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       )),
-                  "function" === typeof fn.componentDidUpdate &&
+                  "function" === typeof unmaskedContext.componentDidUpdate &&
                     (workInProgress.effectTag |= 4),
-                  "function" === typeof fn.getSnapshotBeforeUpdate &&
+                  "function" ===
+                    typeof unmaskedContext.getSnapshotBeforeUpdate &&
                     (workInProgress.effectTag |= 256))
-                : ("function" !== typeof fn.componentDidUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 4),
-                  "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                  "function" !==
+                    typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 256),
-                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedProps = props),
                   (workInProgress.memoizedState = oldState)),
-              (fn.props = needsContext),
-              (fn.state = oldState),
-              (fn.context = props$jscomp$0),
-              (fn = getDerivedStateFromProps))
-            : ("function" !== typeof fn.componentDidUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              (unmaskedContext.props = props),
+              (unmaskedContext.state = oldState),
+              (unmaskedContext.context = ctor))
+            : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 4),
-              "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              "function" !== typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 256),
               (fn = !1));
       return finishClassComponent(
-        current,
+        current$$1,
         workInProgress,
         fn,
-        props,
+        updateExpirationTime,
         renderExpirationTime
       );
     case 3:
       return (
         pushHostRootContext(workInProgress),
-        (props = workInProgress.updateQueue),
-        null !== props
-          ? ((fn = workInProgress.memoizedState),
-            (fn = null !== fn ? fn.element : null),
-            processUpdateQueue(
+        (updateExpirationTime = workInProgress.updateQueue),
+        invariant(
+          null !== updateExpirationTime,
+          "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."
+        ),
+        (fn = workInProgress.memoizedState),
+        (fn = null !== fn ? fn.element : null),
+        processUpdateQueue(
+          workInProgress,
+          updateExpirationTime,
+          workInProgress.pendingProps,
+          null,
+          renderExpirationTime
+        ),
+        (updateExpirationTime = workInProgress.memoizedState.element),
+        updateExpirationTime === fn
+          ? (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
               workInProgress,
-              props,
-              workInProgress.pendingProps,
-              null,
+              renderExpirationTime
+            ))
+          : (reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
               renderExpirationTime
             ),
-            (renderExpirationTime = workInProgress.memoizedState.element),
-            renderExpirationTime === fn
-              ? (current = bailoutOnAlreadyFinishedWork(
-                  current,
-                  workInProgress
-                ))
-              : (reconcileChildren(
-                  current,
-                  workInProgress,
-                  renderExpirationTime
-                ),
-                (current = workInProgress.child)))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+            (current$$1 = workInProgress.child)),
+        current$$1
       );
     case 5:
       return (
-        requiredContext(rootInstanceStackCursor.current),
-        (renderExpirationTime = requiredContext(contextStackCursor$1.current)),
-        (props = workInProgress.type),
-        (props =
-          "AndroidTextInput" === props ||
-          "RCTMultilineTextInputView" === props ||
-          "RCTSinglelineTextInputView" === props ||
-          "RCTText" === props ||
-          "RCTVirtualText" === props),
-        (props =
-          renderExpirationTime.isInAParentText !== props
-            ? { isInAParentText: props }
-            : renderExpirationTime),
-        renderExpirationTime !== props &&
-          (push(contextFiberStackCursor, workInProgress, workInProgress),
-          push(contextStackCursor$1, props, workInProgress)),
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
-        (props = workInProgress.memoizedProps),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current || props !== renderExpirationTime
-          ? ((props = renderExpirationTime.children),
-            markRef(current, workInProgress),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        pushHostContext(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        markRef(current$$1, workInProgress),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        (current$$1 = workInProgress.child),
+        current$$1
       );
     case 6:
       return (
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
         (workInProgress.memoizedProps = workInProgress.pendingProps),
         null
       );
@@ -3768,113 +3822,181 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           workInProgress,
           workInProgress.stateNode.containerInfo
         ),
-        (props = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== props
-          ? (null === current
-              ? (workInProgress.child = reconcileChildFibers(
-                  workInProgress,
-                  null,
-                  props,
-                  renderExpirationTime
-                ))
-              : reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = props),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        null === current$$1
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              updateExpirationTime,
+              renderExpirationTime
+            ))
+          : reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
+              renderExpirationTime
+            ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 14:
       return (
-        (props = workInProgress.type.render),
-        (renderExpirationTime = workInProgress.pendingProps),
-        (fn = workInProgress.ref),
+        (fn = workInProgress.type.render),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = workInProgress.ref),
         didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime ||
-        fn !== (null !== current ? current.ref : null)
-          ? ((props = props(renderExpirationTime, fn)),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        workInProgress.memoizedProps !== updateExpirationTime ||
+        unmaskedContext !== (null !== current$$1 ? current$$1.ref : null)
+          ? ((fn = fn(updateExpirationTime, unmaskedContext)),
+            reconcileChildren(
+              current$$1,
+              workInProgress,
+              fn,
+              renderExpirationTime
+            ),
+            (workInProgress.memoizedProps = updateExpirationTime),
+            (current$$1 = workInProgress.child))
+          : (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            )),
+        current$$1
       );
     case 10:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 11:
       return (
-        (renderExpirationTime = workInProgress.pendingProps.children),
-        didPerformWorkStackCursor.current ||
-        (null !== renderExpirationTime &&
-          workInProgress.memoizedProps !== renderExpirationTime)
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps.children),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 15:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        workInProgress.memoizedProps === renderExpirationTime
-          ? (current = bailoutOnAlreadyFinishedWork(current, workInProgress))
-          : (reconcileChildren(
-              current,
-              workInProgress,
-              renderExpirationTime.children
-            ),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime.children,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 13:
-      return updateContextProvider(
-        current,
-        workInProgress,
-        renderExpirationTime
-      );
-    case 12:
-      a: if (
-        ((fn = workInProgress.type),
-        (unmaskedContext = workInProgress.pendingProps),
-        (needsContext = workInProgress.memoizedProps),
-        (props = fn._currentValue2),
-        (props$jscomp$0 = fn._changedBits2),
-        didPerformWorkStackCursor.current ||
-          0 !== props$jscomp$0 ||
-          needsContext !== unmaskedContext)
-      ) {
-        workInProgress.memoizedProps = unmaskedContext;
-        ctor = unmaskedContext.unstable_observedBits;
-        if (void 0 === ctor || null === ctor) ctor = 1073741823;
-        workInProgress.stateNode = ctor;
-        if (0 !== (props$jscomp$0 & ctor))
+      a: {
+        updateExpirationTime = workInProgress.type._context;
+        fn = workInProgress.pendingProps;
+        unmaskedContext = workInProgress.memoizedProps;
+        needsContext = fn.value;
+        workInProgress.memoizedProps = fn;
+        if (null === unmaskedContext) needsContext = 1073741823;
+        else if (unmaskedContext.value === fn.value) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((props = unmaskedContext.value),
+          (props === needsContext &&
+            (0 !== props || 1 / props === 1 / needsContext)) ||
+            (props !== props && needsContext !== needsContext))
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((needsContext =
+            "function" === typeof updateExpirationTime._calculateChangedBits
+              ? updateExpirationTime._calculateChangedBits(props, needsContext)
+              : 1073741823),
+          (needsContext |= 0),
+          0 === needsContext)
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+        } else
           propagateContextChange(
             workInProgress,
-            fn,
-            props$jscomp$0,
+            updateExpirationTime,
+            needsContext,
             renderExpirationTime
           );
-        else if (needsContext === unmaskedContext) {
-          current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-          break a;
-        }
-        renderExpirationTime = unmaskedContext.children;
-        renderExpirationTime = renderExpirationTime(props);
-        workInProgress.effectTag |= 1;
-        reconcileChildren(current, workInProgress, renderExpirationTime);
-        current = workInProgress.child;
-      } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-      return current;
+        workInProgress.stateNode = needsContext;
+        pushProvider(workInProgress);
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          fn.children,
+          renderExpirationTime
+        );
+        current$$1 = workInProgress.child;
+      }
+      return current$$1;
+    case 12:
+      return (
+        (unmaskedContext = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (unmaskedContext = readContext(
+          unmaskedContext,
+          updateExpirationTime.unstable_observedBits
+        )),
+        (fn = fn(unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
+      );
     default:
       invariant(
         !1,
@@ -3972,160 +4094,16 @@ updateHostText$1 = function(current, workInProgress, oldText, newText) {
     )),
     (workInProgress.effectTag |= 4));
 };
-function completeWork(current, workInProgress) {
-  var newProps = workInProgress.pendingProps;
-  switch (workInProgress.tag) {
-    case 1:
-      return null;
-    case 2:
-      return popContextProvider(workInProgress), null;
-    case 3:
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      newProps = workInProgress.stateNode;
-      newProps.pendingContext &&
-        ((newProps.context = newProps.pendingContext),
-        (newProps.pendingContext = null));
-      if (null === current || null === current.child)
-        workInProgress.effectTag &= -3;
-      updateHostContainer(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      var rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        ),
-        type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode) {
-        var oldProps = current.memoizedProps,
-          instance = workInProgress.stateNode,
-          currentHostContext = requiredContext(contextStackCursor$1.current),
-          updatePayload = diffProperties(
-            null,
-            oldProps,
-            newProps,
-            instance.canonical.viewConfig.validAttributes
-          );
-        instance.canonical.currentProps = newProps;
-        updateHostComponent$1(
-          current,
-          workInProgress,
-          updatePayload,
-          type,
-          oldProps,
-          newProps,
-          rootContainerInstance,
-          currentHostContext
-        );
-        current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      } 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
-          );
-        instance = requiredContext(contextStackCursor$1.current);
-        current = nextReactTag;
-        nextReactTag += 2;
-        oldProps = ReactNativeViewConfigRegistry.get(type);
-        invariant(
-          "RCTView" !== type || !instance.isInAParentText,
-          "Nesting of <View> within <Text> is not currently supported."
-        );
-        type = diffProperties(
-          null,
-          emptyObject$1,
-          newProps,
-          oldProps.validAttributes
-        );
-        rootContainerInstance = FabricUIManager.createNode(
-          current,
-          oldProps.uiViewClassName,
-          rootContainerInstance,
-          type,
-          workInProgress
-        );
-        newProps = new ReactFabricHostComponent(current, oldProps, newProps);
-        newProps = { node: rootContainerInstance, canonical: newProps };
-        appendAllChildren(newProps, workInProgress);
-        workInProgress.stateNode = newProps;
-        null !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      }
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        updateHostText$1(
-          current,
-          workInProgress,
-          current.memoizedProps,
-          newProps
-        );
-      else {
-        if ("string" !== typeof 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
-          );
-        rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        );
-        type = requiredContext(contextStackCursor$1.current);
-        workInProgress.stateNode = createTextInstance(
-          newProps,
-          rootContainerInstance,
-          type,
-          workInProgress
-        );
-      }
-      return null;
-    case 14:
-      return null;
-    case 16:
-      return null;
-    case 10:
-      return null;
-    case 11:
-      return null;
-    case 15:
-      return null;
-    case 4:
-      return (
-        popHostContainer(workInProgress),
-        updateHostContainer(workInProgress),
-        null
-      );
-    case 13:
-      return popProvider(workInProgress), null;
-    case 12:
-      return null;
-    case 0:
-      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."
-      );
-  }
-}
 function logError(boundary, errorInfo) {
   var source = errorInfo.source,
     stack = errorInfo.stack;
   null === stack &&
     null !== source &&
-    (stack = getStackAddendumByWorkInProgressFiber(source));
-  null !== source && getComponentName(source);
+    (stack = getStackByFiberInDevAndProd(source));
+  null !== source && getComponentName(source.type);
   source = null !== stack ? stack : "";
   errorInfo = errorInfo.value;
-  null !== boundary && 2 === boundary.tag && getComponentName(boundary);
+  null !== boundary && 2 === boundary.tag && getComponentName(boundary.type);
   try {
     if (errorInfo instanceof Error) {
       var message = errorInfo.message,
@@ -4147,18 +4125,18 @@ function logError(boundary, errorInfo) {
     (e && e.suppressReactErrorLogging) || console.error(e);
   }
 }
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (null !== ref)
     if ("function" === typeof ref)
       try {
         ref(null);
       } catch (refError) {
-        captureCommitPhaseError(current, refError);
+        captureCommitPhaseError(current$$1, refError);
       }
     else ref.current = null;
 }
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case 2:
       break;
@@ -4220,10 +4198,12 @@ function unwindWork(workInProgress) {
         popHostContainer(workInProgress),
         popTopLevelContextObject(workInProgress),
         (effectTag = workInProgress.effectTag),
-        effectTag & 1024
-          ? ((workInProgress.effectTag = (effectTag & -1025) | 64),
-            workInProgress)
-          : null
+        invariant(
+          0 === (effectTag & 64),
+          "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."
+        ),
+        (workInProgress.effectTag = (effectTag & -1025) | 64),
+        workInProgress
       );
     case 5:
       return popHostContext(workInProgress), null;
@@ -4243,16 +4223,14 @@ function unwindWork(workInProgress) {
       return null;
   }
 }
-var originalStartTimeMs = now$1(),
-  mostRecentCurrentTime = 2,
-  mostRecentCurrentTimeMs = originalStartTimeMs,
+var Dispatcher = { readContext: readContext },
+  ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
   lastUniqueAsyncExpiration = 0,
   expirationContext = 0,
   isWorking = !1,
   nextUnitOfWork = null,
   nextRoot = null,
   nextRenderExpirationTime = 0,
-  nextLatestTimeoutMs = -1,
   nextRenderDidError = !1,
   nextEffect = null,
   isCommitting$1 = !1,
@@ -4286,72 +4264,198 @@ function resetStack() {
     }
   nextRoot = null;
   nextRenderExpirationTime = 0;
-  nextLatestTimeoutMs = -1;
   nextRenderDidError = !1;
   nextUnitOfWork = null;
 }
-function completeUnitOfWork(workInProgress$jscomp$0) {
+function completeUnitOfWork(workInProgress) {
   for (;;) {
-    var current = workInProgress$jscomp$0.alternate,
-      returnFiber = workInProgress$jscomp$0.return,
-      siblingFiber = workInProgress$jscomp$0.sibling;
-    if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
-      current = completeWork(
-        current,
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      var workInProgress = workInProgress$jscomp$0;
+    var current$$1 = workInProgress.alternate,
+      returnFiber = workInProgress.return,
+      siblingFiber = workInProgress.sibling;
+    if (0 === (workInProgress.effectTag & 512)) {
+      var current = current$$1;
+      current$$1 = workInProgress;
+      var newProps = current$$1.pendingProps;
+      switch (current$$1.tag) {
+        case 1:
+          break;
+        case 2:
+          popContextProvider(current$$1);
+          break;
+        case 3:
+          popHostContainer(current$$1);
+          popTopLevelContextObject(current$$1);
+          var fiberRoot = current$$1.stateNode;
+          fiberRoot.pendingContext &&
+            ((fiberRoot.context = fiberRoot.pendingContext),
+            (fiberRoot.pendingContext = null));
+          if (null === current || null === current.child)
+            current$$1.effectTag &= -3;
+          updateHostContainer(current$$1);
+          break;
+        case 5:
+          popHostContext(current$$1);
+          fiberRoot = requiredContext(rootInstanceStackCursor.current);
+          var type = current$$1.type;
+          if (null !== current && null != current$$1.stateNode) {
+            var oldProps = current.memoizedProps,
+              instance = current$$1.stateNode,
+              currentHostContext = requiredContext(
+                contextStackCursor$1.current
+              ),
+              newProps$jscomp$0 = newProps,
+              updatePayload = diffProperties(
+                null,
+                oldProps,
+                newProps$jscomp$0,
+                instance.canonical.viewConfig.validAttributes
+              );
+            instance.canonical.currentProps = newProps$jscomp$0;
+            updateHostComponent$1(
+              current,
+              current$$1,
+              updatePayload,
+              type,
+              oldProps,
+              newProps,
+              fiberRoot,
+              currentHostContext
+            );
+            current.ref !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else
+            newProps
+              ? ((oldProps = requiredContext(contextStackCursor$1.current)),
+                (current = newProps),
+                (instance = oldProps),
+                (currentHostContext = current$$1),
+                (newProps = nextReactTag),
+                (nextReactTag += 2),
+                (oldProps = ReactNativeViewConfigRegistry.get(type)),
+                invariant(
+                  "RCTView" !== type || !instance.isInAParentText,
+                  "Nesting of <View> within <Text> is not currently supported."
+                ),
+                (type = diffProperties(
+                  null,
+                  emptyObject,
+                  current,
+                  oldProps.validAttributes
+                )),
+                (fiberRoot = FabricUIManager.createNode(
+                  newProps,
+                  oldProps.uiViewClassName,
+                  fiberRoot,
+                  type,
+                  currentHostContext
+                )),
+                (current = new ReactFabricHostComponent(
+                  newProps,
+                  oldProps,
+                  current
+                )),
+                (fiberRoot = { node: fiberRoot, canonical: current }),
+                appendAllChildren(fiberRoot, current$$1),
+                (current$$1.stateNode = fiberRoot),
+                null !== current$$1.ref && (current$$1.effectTag |= 128))
+              : invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                );
+          break;
+        case 6:
+          fiberRoot = newProps;
+          current && null != current$$1.stateNode
+            ? updateHostText$1(
+                current,
+                current$$1,
+                current.memoizedProps,
+                fiberRoot
+              )
+            : ("string" !== typeof fiberRoot &&
+                invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                ),
+              (current = requiredContext(rootInstanceStackCursor.current)),
+              (newProps = requiredContext(contextStackCursor$1.current)),
+              (current$$1.stateNode = createTextInstance(
+                fiberRoot,
+                current,
+                newProps,
+                current$$1
+              )));
+          break;
+        case 14:
+          break;
+        case 16:
+          break;
+        case 10:
+          break;
+        case 11:
+          break;
+        case 15:
+          break;
+        case 4:
+          popHostContainer(current$$1);
+          updateHostContainer(current$$1);
+          break;
+        case 13:
+          popProvider(current$$1);
+          break;
+        case 12:
+          break;
+        case 0:
+          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."
+          );
+      }
+      current$$1 = nextUnitOfWork = null;
+      fiberRoot = workInProgress;
       if (
         1073741823 === nextRenderExpirationTime ||
-        1073741823 !== workInProgress.expirationTime
+        1073741823 !== fiberRoot.childExpirationTime
       ) {
-        var newExpirationTime = 0;
-        switch (workInProgress.tag) {
-          case 3:
-          case 2:
-            var updateQueue = workInProgress.updateQueue;
-            null !== updateQueue &&
-              (newExpirationTime = updateQueue.expirationTime);
+        current = 0;
+        for (newProps = fiberRoot.child; null !== newProps; ) {
+          type = newProps.expirationTime;
+          oldProps = newProps.childExpirationTime;
+          if (0 === current || (0 !== type && type < current)) current = type;
+          if (0 === current || (0 !== oldProps && oldProps < current))
+            current = oldProps;
+          newProps = newProps.sibling;
         }
-        for (updateQueue = workInProgress.child; null !== updateQueue; )
-          0 !== updateQueue.expirationTime &&
-            (0 === newExpirationTime ||
-              newExpirationTime > updateQueue.expirationTime) &&
-            (newExpirationTime = updateQueue.expirationTime),
-            (updateQueue = updateQueue.sibling);
-        workInProgress.expirationTime = newExpirationTime;
+        fiberRoot.childExpirationTime = current;
       }
-      if (null !== current) return current;
+      if (null !== current$$1) return current$$1;
       null !== returnFiber &&
         0 === (returnFiber.effectTag & 512) &&
         (null === returnFiber.firstEffect &&
-          (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect),
-        null !== workInProgress$jscomp$0.lastEffect &&
+          (returnFiber.firstEffect = workInProgress.firstEffect),
+        null !== workInProgress.lastEffect &&
           (null !== returnFiber.lastEffect &&
-            (returnFiber.lastEffect.nextEffect =
-              workInProgress$jscomp$0.firstEffect),
-          (returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect)),
-        1 < workInProgress$jscomp$0.effectTag &&
+            (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect),
+          (returnFiber.lastEffect = workInProgress.lastEffect)),
+        1 < workInProgress.effectTag &&
           (null !== returnFiber.lastEffect
-            ? (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0)
-            : (returnFiber.firstEffect = workInProgress$jscomp$0),
-          (returnFiber.lastEffect = workInProgress$jscomp$0)));
+            ? (returnFiber.lastEffect.nextEffect = workInProgress)
+            : (returnFiber.firstEffect = workInProgress),
+          (returnFiber.lastEffect = workInProgress)));
     } else {
-      workInProgress$jscomp$0 = unwindWork(
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      if (null !== workInProgress$jscomp$0)
-        return (
-          (workInProgress$jscomp$0.effectTag &= 511), workInProgress$jscomp$0
-        );
+      workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+      if (null !== workInProgress)
+        return (workInProgress.effectTag &= 511), workInProgress;
       null !== returnFiber &&
         ((returnFiber.firstEffect = returnFiber.lastEffect = null),
         (returnFiber.effectTag |= 512));
     }
     if (null !== siblingFiber) return siblingFiber;
-    if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;
+    if (null !== returnFiber) workInProgress = returnFiber;
     else break;
   }
   return null;
@@ -4363,32 +4467,31 @@ function performUnitOfWork(workInProgress) {
     nextRenderExpirationTime
   );
   null === next && (next = completeUnitOfWork(workInProgress));
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
   return next;
 }
-function renderRoot(root$jscomp$0, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isWorking = !0;
-  var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
+  var expirationTime = root.nextExpirationTimeToWorkOn;
   if (
     expirationTime !== nextRenderExpirationTime ||
-    root$jscomp$0 !== nextRoot ||
+    root !== nextRoot ||
     null === nextUnitOfWork
   )
     resetStack(),
-      (nextRoot = root$jscomp$0),
+      (nextRoot = root),
       (nextRenderExpirationTime = expirationTime),
-      (nextLatestTimeoutMs = -1),
-      (nextRenderDidError = !1),
       (nextUnitOfWork = createWorkInProgress(
         nextRoot.current,
         null,
         nextRenderExpirationTime
       )),
-      (root$jscomp$0.pendingCommitExpirationTime = 0);
+      (root.pendingCommitExpirationTime = 0);
   var didFatal = !1;
   do {
     try {
@@ -4406,110 +4509,117 @@ function renderRoot(root$jscomp$0, isYieldy) {
           null !== nextUnitOfWork,
           "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it."
         );
-        isYieldy = nextUnitOfWork;
-        var returnFiber = isYieldy.return;
-        if (null === returnFiber) {
-          didFatal = !0;
-          onUncaughtError(thrownValue);
-          break;
-        }
-        a: {
-          var root = root$jscomp$0,
-            returnFiber$jscomp$0 = returnFiber,
-            sourceFiber = isYieldy,
-            value = thrownValue;
-          returnFiber = nextRenderExpirationTime;
-          sourceFiber.effectTag |= 512;
-          sourceFiber.firstEffect = sourceFiber.lastEffect = null;
-          nextRenderDidError = !0;
-          if (
-            (root.didError || 1 === returnFiber) &&
-            (returnFiber === root.latestPendingTime ||
-              returnFiber === root.latestSuspendedTime)
-          ) {
-            value = createCapturedValue(value, sourceFiber);
-            root = returnFiber$jscomp$0;
+        var sourceFiber = nextUnitOfWork,
+          returnFiber = sourceFiber.return;
+        if (null === returnFiber) (didFatal = !0), onUncaughtError(thrownValue);
+        else {
+          a: {
+            var returnFiber$jscomp$0 = returnFiber,
+              sourceFiber$jscomp$0 = sourceFiber,
+              value = thrownValue;
+            returnFiber = nextRenderExpirationTime;
+            sourceFiber$jscomp$0.effectTag |= 512;
+            sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+            nextRenderDidError = !0;
+            value = createCapturedValue(value, sourceFiber$jscomp$0);
             do {
-              switch (root.tag) {
+              switch (returnFiber$jscomp$0.tag) {
                 case 3:
-                  root.effectTag |= 1024;
-                  value = createRootErrorUpdate(root, value, returnFiber);
-                  enqueueCapturedUpdate(root, value, returnFiber);
+                  returnFiber$jscomp$0.effectTag |= 1024;
+                  returnFiber$jscomp$0.expirationTime = returnFiber;
+                  returnFiber = createRootErrorUpdate(
+                    returnFiber$jscomp$0,
+                    value,
+                    returnFiber
+                  );
+                  enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                   break a;
                 case 2:
+                  sourceFiber$jscomp$0 = value;
+                  var instance = returnFiber$jscomp$0.stateNode;
                   if (
-                    ((returnFiber$jscomp$0 = value),
-                    (sourceFiber = root.stateNode),
-                    0 === (root.effectTag & 64) &&
-                      null !== sourceFiber &&
-                      "function" === typeof sourceFiber.componentDidCatch &&
-                      (null === legacyErrorBoundariesThatAlreadyFailed ||
-                        !legacyErrorBoundariesThatAlreadyFailed.has(
-                          sourceFiber
-                        )))
+                    0 === (returnFiber$jscomp$0.effectTag & 64) &&
+                    null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))
                   ) {
-                    root.effectTag |= 1024;
-                    value = createClassErrorUpdate(
-                      root,
+                    returnFiber$jscomp$0.effectTag |= 1024;
+                    returnFiber$jscomp$0.expirationTime = returnFiber;
+                    returnFiber = createClassErrorUpdate(
                       returnFiber$jscomp$0,
+                      sourceFiber$jscomp$0,
                       returnFiber
                     );
-                    enqueueCapturedUpdate(root, value, returnFiber);
+                    enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                     break a;
                   }
               }
-              root = root.return;
-            } while (null !== root);
+              returnFiber$jscomp$0 = returnFiber$jscomp$0.return;
+            } while (null !== returnFiber$jscomp$0);
           }
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        nextUnitOfWork = completeUnitOfWork(isYieldy);
       }
     }
     break;
   } while (1);
   isWorking = !1;
-  didFatal
-    ? (root$jscomp$0.finishedWork = null)
-    : null === nextUnitOfWork
-      ? ((didFatal = root$jscomp$0.current.alternate),
-        invariant(
-          null !== didFatal,
-          "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
-        ),
-        0 === (didFatal.effectTag & 512)
-          ? ((root$jscomp$0.pendingCommitExpirationTime = expirationTime),
-            (root$jscomp$0.finishedWork = didFatal))
-          : (!nextRenderDidError ||
-            (expirationTime !== root$jscomp$0.latestPendingTime &&
-              expirationTime !== root$jscomp$0.latestSuspendedTime)
-              ? ((didFatal = root$jscomp$0.earliestPendingTime),
-                (isYieldy = root$jscomp$0.latestPendingTime),
-                didFatal === expirationTime
-                  ? (root$jscomp$0.earliestPendingTime =
-                      isYieldy === expirationTime
-                        ? (root$jscomp$0.latestPendingTime = 0)
-                        : isYieldy)
-                  : isYieldy === expirationTime &&
-                    (root$jscomp$0.latestPendingTime = didFatal),
-                (didFatal = root$jscomp$0.latestSuspendedTime),
-                didFatal === expirationTime &&
-                  (root$jscomp$0.latestPingedTime = 0),
-                (isYieldy = root$jscomp$0.earliestSuspendedTime),
-                0 === isYieldy
-                  ? (root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime)
-                  : isYieldy > expirationTime
-                    ? (root$jscomp$0.earliestSuspendedTime = expirationTime)
-                    : didFatal < expirationTime &&
-                      (root$jscomp$0.latestSuspendedTime = expirationTime))
-              : (root$jscomp$0.didError = !0),
-            findNextPendingPriorityLevel(root$jscomp$0),
-            onSuspend(
-              root$jscomp$0,
-              expirationTime,
-              root$jscomp$0.expirationTime,
-              nextLatestTimeoutMs
-            )))
-      : (root$jscomp$0.finishedWork = null);
+  lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = ReactCurrentOwner$2.currentDispatcher = null;
+  if (didFatal) (nextRoot = null), (root.finishedWork = null);
+  else if (null !== nextUnitOfWork) root.finishedWork = null;
+  else {
+    isYieldy = root.current.alternate;
+    invariant(
+      null !== isYieldy,
+      "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
+    );
+    nextRoot = null;
+    if (nextRenderDidError) {
+      didFatal = root.latestPendingTime;
+      sourceFiber = root.latestSuspendedTime;
+      returnFiber = root.latestPingedTime;
+      if (
+        (0 !== didFatal && didFatal > expirationTime) ||
+        (0 !== sourceFiber && sourceFiber > expirationTime) ||
+        (0 !== returnFiber && returnFiber > expirationTime)
+      ) {
+        root.didError = !1;
+        isExpired = root.latestPingedTime;
+        0 !== isExpired &&
+          isExpired <= expirationTime &&
+          (root.latestPingedTime = 0);
+        isExpired = root.earliestPendingTime;
+        isYieldy = root.latestPendingTime;
+        isExpired === expirationTime
+          ? (root.earliestPendingTime =
+              isYieldy === expirationTime
+                ? (root.latestPendingTime = 0)
+                : isYieldy)
+          : isYieldy === expirationTime && (root.latestPendingTime = isExpired);
+        isExpired = root.earliestSuspendedTime;
+        isYieldy = root.latestSuspendedTime;
+        0 === isExpired
+          ? (root.earliestSuspendedTime = root.latestSuspendedTime = expirationTime)
+          : isExpired > expirationTime
+            ? (root.earliestSuspendedTime = expirationTime)
+            : isYieldy < expirationTime &&
+              (root.latestSuspendedTime = expirationTime);
+        findNextExpirationTimeToWorkOn(expirationTime, root);
+        root.expirationTime = root.expirationTime;
+        return;
+      }
+      if (!root.didError && !isExpired) {
+        root.didError = !0;
+        root.nextExpirationTimeToWorkOn = expirationTime;
+        root.expirationTime = 1;
+        return;
+      }
+    }
+    root.pendingCommitExpirationTime = expirationTime;
+    root.finishedWork = isYieldy;
+  }
 }
 function captureCommitPhaseError(fiber, error) {
   var JSCompiler_inline_result;
@@ -4535,7 +4645,7 @@ function captureCommitPhaseError(fiber, error) {
           ) {
             fiber = createCapturedValue(error, fiber);
             fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
-            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+            enqueueUpdate(JSCompiler_inline_result, fiber);
             scheduleWork(JSCompiler_inline_result, 1);
             JSCompiler_inline_result = void 0;
             break a;
@@ -4544,7 +4654,7 @@ function captureCommitPhaseError(fiber, error) {
         case 3:
           fiber = createCapturedValue(error, fiber);
           fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
-          enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+          enqueueUpdate(JSCompiler_inline_result, fiber);
           scheduleWork(JSCompiler_inline_result, 1);
           JSCompiler_inline_result = void 0;
           break a;
@@ -4558,23 +4668,25 @@ function captureCommitPhaseError(fiber, error) {
         JSCompiler_inline_result,
         1
       )),
-      enqueueUpdate(fiber, JSCompiler_inline_result, 1),
+      enqueueUpdate(fiber, JSCompiler_inline_result),
       scheduleWork(fiber, 1));
     JSCompiler_inline_result = void 0;
   }
   return JSCompiler_inline_result;
 }
 function computeExpirationForFiber(currentTime, fiber) {
-  currentTime =
-    0 !== expirationContext
-      ? expirationContext
-      : isWorking
-        ? isCommitting$1 ? 1 : nextRenderExpirationTime
-        : fiber.mode & 1
-          ? isBatchingInteractiveUpdates
+  0 !== expirationContext
+    ? (currentTime = expirationContext)
+    : isWorking
+      ? (currentTime = isCommitting$1 ? 1 : nextRenderExpirationTime)
+      : fiber.mode & 1
+        ? ((currentTime = isBatchingInteractiveUpdates
             ? 2 + 10 * ((((currentTime - 2 + 15) / 10) | 0) + 1)
-            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)
-          : 1;
+            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)),
+          null !== nextRoot &&
+            currentTime === nextRenderExpirationTime &&
+            (currentTime += 1))
+        : (currentTime = 1);
   isBatchingInteractiveUpdates &&
     (0 === lowestPendingInteractiveExpirationTime ||
       currentTime > lowestPendingInteractiveExpirationTime) &&
@@ -4582,35 +4694,51 @@ function computeExpirationForFiber(currentTime, fiber) {
   return currentTime;
 }
 function scheduleWork(fiber, expirationTime) {
-  for (; null !== fiber; ) {
+  a: {
     if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime)
       fiber.expirationTime = expirationTime;
-    null !== fiber.alternate &&
-      (0 === fiber.alternate.expirationTime ||
-        fiber.alternate.expirationTime > expirationTime) &&
-      (fiber.alternate.expirationTime = expirationTime);
-    if (null === fiber.return)
-      if (3 === fiber.tag) {
-        var root = fiber.stateNode;
-        !isWorking &&
-          0 !== nextRenderExpirationTime &&
-          expirationTime < nextRenderExpirationTime &&
-          resetStack();
-        markPendingPriorityLevel(root, expirationTime);
-        (isWorking && !isCommitting$1 && nextRoot === root) ||
-          requestWork(root, root.expirationTime);
-        nestedUpdateCount > NESTED_UPDATE_LIMIT &&
-          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."
-          );
-      } else break;
-    fiber = fiber.return;
+    var alternate = fiber.alternate;
+    null !== alternate &&
+      (0 === alternate.expirationTime ||
+        alternate.expirationTime > expirationTime) &&
+      (alternate.expirationTime = expirationTime);
+    var node = fiber.return;
+    if (null === node && 3 === fiber.tag) fiber = fiber.stateNode;
+    else {
+      for (; null !== node; ) {
+        alternate = node.alternate;
+        if (
+          0 === node.childExpirationTime ||
+          node.childExpirationTime > expirationTime
+        )
+          node.childExpirationTime = expirationTime;
+        null !== alternate &&
+          (0 === alternate.childExpirationTime ||
+            alternate.childExpirationTime > expirationTime) &&
+          (alternate.childExpirationTime = expirationTime);
+        if (null === node.return && 3 === node.tag) {
+          fiber = node.stateNode;
+          break a;
+        }
+        node = node.return;
+      }
+      fiber = null;
+    }
   }
-}
-function recalculateCurrentTime() {
-  mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
-  return (mostRecentCurrentTime = ((mostRecentCurrentTimeMs / 10) | 0) + 2);
+  null !== fiber &&
+    (!isWorking &&
+      0 !== nextRenderExpirationTime &&
+      expirationTime < nextRenderExpirationTime &&
+      resetStack(),
+    markPendingPriorityLevel(fiber, expirationTime),
+    (isWorking && !isCommitting$1 && nextRoot === fiber) ||
+      requestWork(fiber, fiber.expirationTime),
+    nestedUpdateCount > NESTED_UPDATE_LIMIT &&
+      ((nestedUpdateCount = 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."
+      )));
 }
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
@@ -4637,9 +4765,16 @@ var firstScheduledRoot = null,
   isUnbatchingUpdates = !1,
   isBatchingInteractiveUpdates = !1,
   completedBatches = null,
-  NESTED_UPDATE_LIMIT = 1e3,
+  originalStartTimeMs = now$1(),
+  currentRendererTime = ((originalStartTimeMs / 10) | 0) + 2,
+  currentSchedulerTime = currentRendererTime,
+  NESTED_UPDATE_LIMIT = 50,
   nestedUpdateCount = 0,
+  lastCommittedRootDuringThisBatch = null,
   timeHeuristicForUnitOfWork = 1;
+function recomputeCurrentRendererTime() {
+  currentRendererTime = (((now$1() - originalStartTimeMs) / 10) | 0) + 2;
+}
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (0 !== callbackExpirationTime) {
     if (expirationTime > callbackExpirationTime) return;
@@ -4654,21 +4789,16 @@ function scheduleCallbackWithExpirationTime(expirationTime) {
   scheduledCallback = performAsyncWork;
   callbackID = setTimeout(setTimeoutCallback, 1);
 }
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  0 <= timeoutMs &&
-    setTimeout(function() {
-      var latestSuspendedTime = root.latestSuspendedTime;
-      0 !== latestSuspendedTime &&
-        latestSuspendedTime <= suspendedExpirationTime &&
-        ((latestSuspendedTime = root.latestPingedTime),
-        0 === latestSuspendedTime ||
-          latestSuspendedTime < suspendedExpirationTime) &&
-        (root.latestPingedTime = suspendedExpirationTime);
-      findNextPendingPriorityLevel(root);
-      latestSuspendedTime = root.expirationTime;
-      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
-    }, timeoutMs);
-  root.expirationTime = expirationTime;
+function requestCurrentTime() {
+  if (isRendering) return currentSchedulerTime;
+  findHighestPriorityRoot();
+  if (
+    0 === nextFlushedExpirationTime ||
+    1073741823 === nextFlushedExpirationTime
+  )
+    recomputeCurrentRendererTime(),
+      (currentSchedulerTime = currentRendererTime);
+  return currentSchedulerTime;
 }
 function requestWork(root, expirationTime) {
   if (null === root.nextScheduledRoot)
@@ -4691,7 +4821,7 @@ function requestWork(root, expirationTime) {
       ? isUnbatchingUpdates &&
         ((nextFlushedRoot = root),
         (nextFlushedExpirationTime = 1),
-        performWorkOnRoot(root, 1, !1))
+        performWorkOnRoot(root, 1, !0))
       : 1 === expirationTime
         ? performWork(1, null)
         : scheduleCallbackWithExpirationTime(expirationTime));
@@ -4740,12 +4870,6 @@ function findHighestPriorityRoot() {
         root = root.nextScheduledRoot;
       }
     }
-  previousScheduledRoot = nextFlushedRoot;
-  null !== previousScheduledRoot &&
-  previousScheduledRoot === highestPriorityRoot &&
-  1 === highestPriorityWork
-    ? nestedUpdateCount++
-    : (nestedUpdateCount = 0);
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -4757,18 +4881,23 @@ function performWork(minExpirationTime, dl) {
   findHighestPriorityRoot();
   if (null !== deadline)
     for (
-      ;
+      recomputeCurrentRendererTime(),
+        currentSchedulerTime = currentRendererTime;
       null !== nextFlushedRoot &&
       0 !== nextFlushedExpirationTime &&
       (0 === minExpirationTime ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime);
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime);
 
     )
-      recalculateCurrentTime(),
-        performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
-        findHighestPriorityRoot();
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      ),
+        findHighestPriorityRoot(),
+        recomputeCurrentRendererTime(),
+        (currentSchedulerTime = currentRendererTime);
   else
     for (
       ;
@@ -4778,22 +4907,22 @@ function performWork(minExpirationTime, dl) {
         minExpirationTime >= nextFlushedExpirationTime);
 
     )
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1),
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
         findHighestPriorityRoot();
   null !== deadline && ((callbackExpirationTime = 0), (callbackID = null));
   0 !== nextFlushedExpirationTime &&
     scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
   deadline = null;
   deadlineDidExpire = !1;
-  finishRendering();
-}
-function finishRendering() {
   nestedUpdateCount = 0;
-  if (null !== completedBatches) {
-    var batches = completedBatches;
-    completedBatches = null;
-    for (var i = 0; i < batches.length; i++) {
-      var batch = batches[i];
+  lastCommittedRootDuringThisBatch = null;
+  if (null !== completedBatches)
+    for (
+      minExpirationTime = completedBatches, completedBatches = null, dl = 0;
+      dl < minExpirationTime.length;
+      dl++
+    ) {
+      var batch = minExpirationTime[dl];
       try {
         batch._onComplete();
       } catch (error) {
@@ -4801,37 +4930,38 @@ function finishRendering() {
           ((hasUnhandledError = !0), (unhandledError = error));
       }
     }
-  }
   if (hasUnhandledError)
-    throw ((batches = unhandledError),
+    throw ((minExpirationTime = unhandledError),
     (unhandledError = null),
     (hasUnhandledError = !1),
-    batches);
+    minExpirationTime);
 }
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isRendering = !0;
-  isYieldy
-    ? ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot$1(root, isYieldy, expirationTime)
+  if (null === deadline || isExpired) {
+    var finishedWork = root.finishedWork;
+    null !== finishedWork
+      ? completeRoot$1(root, finishedWork, expirationTime)
+      : ((root.finishedWork = null),
+        renderRoot(root, !1, isExpired),
+        (finishedWork = root.finishedWork),
+        null !== finishedWork &&
+          completeRoot$1(root, finishedWork, expirationTime));
+  } else
+    (finishedWork = root.finishedWork),
+      null !== finishedWork
+        ? completeRoot$1(root, finishedWork, expirationTime)
         : ((root.finishedWork = null),
-          renderRoot(root, !0),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy &&
+          renderRoot(root, !0, isExpired),
+          (finishedWork = root.finishedWork),
+          null !== finishedWork &&
             (shouldYield()
-              ? (root.finishedWork = isYieldy)
-              : completeRoot$1(root, isYieldy, expirationTime))))
-    : ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot$1(root, isYieldy, expirationTime)
-        : ((root.finishedWork = null),
-          renderRoot(root, !1),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy && completeRoot$1(root, isYieldy, expirationTime)));
+              ? (root.finishedWork = finishedWork)
+              : completeRoot$1(root, finishedWork, expirationTime)));
   isRendering = !1;
 }
 function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
@@ -4849,6 +4979,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
     return;
   }
   root.finishedWork = null;
+  root === lastCommittedRootDuringThisBatch
+    ? nestedUpdateCount++
+    : ((lastCommittedRootDuringThisBatch = root), (nestedUpdateCount = 0));
   isCommitting$1 = isWorking = !0;
   invariant(
     root.current !== finishedWork$jscomp$0,
@@ -4861,34 +4994,39 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
   );
   root.pendingCommitExpirationTime = 0;
   firstBatch = finishedWork$jscomp$0.expirationTime;
-  recalculateCurrentTime();
+  var childExpirationTimeBeforeCommit =
+    finishedWork$jscomp$0.childExpirationTime;
+  firstBatch =
+    0 === firstBatch ||
+    (0 !== childExpirationTimeBeforeCommit &&
+      childExpirationTimeBeforeCommit < firstBatch)
+      ? childExpirationTimeBeforeCommit
+      : firstBatch;
   root.didError = !1;
-  if (0 === firstBatch)
-    (root.earliestPendingTime = 0),
+  0 === firstBatch
+    ? ((root.earliestPendingTime = 0),
       (root.latestPendingTime = 0),
       (root.earliestSuspendedTime = 0),
       (root.latestSuspendedTime = 0),
-      (root.latestPingedTime = 0);
-  else {
-    var latestPendingTime = root.latestPendingTime;
-    0 !== latestPendingTime &&
-      (latestPendingTime < firstBatch
-        ? (root.earliestPendingTime = root.latestPendingTime = 0)
-        : root.earliestPendingTime < firstBatch &&
-          (root.earliestPendingTime = root.latestPendingTime));
-    latestPendingTime = root.earliestSuspendedTime;
-    0 === latestPendingTime
-      ? markPendingPriorityLevel(root, firstBatch)
-      : firstBatch > root.latestSuspendedTime
-        ? ((root.earliestSuspendedTime = 0),
-          (root.latestSuspendedTime = 0),
-          (root.latestPingedTime = 0),
-          markPendingPriorityLevel(root, firstBatch))
-        : firstBatch < latestPendingTime &&
-          markPendingPriorityLevel(root, firstBatch);
-  }
-  findNextPendingPriorityLevel(root);
-  ReactCurrentOwner.current = null;
+      (root.latestPingedTime = 0))
+    : ((childExpirationTimeBeforeCommit = root.latestPendingTime),
+      0 !== childExpirationTimeBeforeCommit &&
+        (childExpirationTimeBeforeCommit < firstBatch
+          ? (root.earliestPendingTime = root.latestPendingTime = 0)
+          : root.earliestPendingTime < firstBatch &&
+            (root.earliestPendingTime = root.latestPendingTime)),
+      (childExpirationTimeBeforeCommit = root.earliestSuspendedTime),
+      0 === childExpirationTimeBeforeCommit
+        ? markPendingPriorityLevel(root, firstBatch)
+        : firstBatch > root.latestSuspendedTime
+          ? ((root.earliestSuspendedTime = 0),
+            (root.latestSuspendedTime = 0),
+            (root.latestPingedTime = 0),
+            markPendingPriorityLevel(root, firstBatch))
+          : firstBatch < childExpirationTimeBeforeCommit &&
+            markPendingPriorityLevel(root, firstBatch));
+  findNextExpirationTimeToWorkOn(0, root);
+  ReactCurrentOwner$2.current = null;
   1 < finishedWork$jscomp$0.effectTag
     ? null !== finishedWork$jscomp$0.lastEffect
       ? ((finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0),
@@ -4896,18 +5034,18 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
       : (firstBatch = finishedWork$jscomp$0)
     : (firstBatch = finishedWork$jscomp$0.firstEffect);
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    latestPendingTime = !1;
+    childExpirationTimeBeforeCommit = !1;
     var error = void 0;
     try {
       for (; null !== nextEffect; ) {
         if (nextEffect.effectTag & 256) {
-          var current = nextEffect.alternate,
+          var current$$1 = nextEffect.alternate,
             finishedWork = nextEffect;
           switch (finishedWork.tag) {
             case 2:
-              if (finishedWork.effectTag & 256 && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
+              if (finishedWork.effectTag & 256 && null !== current$$1) {
+                var prevProps = current$$1.memoizedProps,
+                  prevState = current$$1.memoizedState,
                   instance = finishedWork.stateNode;
                 instance.props = finishedWork.memoizedProps;
                 instance.state = finishedWork.memoizedState;
@@ -4933,9 +5071,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (latestPendingTime = !0), (error = e);
+      (childExpirationTimeBeforeCommit = !0), (error = e);
     }
-    latestPendingTime &&
+    childExpirationTimeBeforeCommit &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -4944,15 +5082,15 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    current = !1;
+    current$$1 = !1;
     prevProps = void 0;
     try {
       for (; null !== nextEffect; ) {
         var effectTag = nextEffect.effectTag;
         if (effectTag & 128) {
-          var current$jscomp$0 = nextEffect.alternate;
-          if (null !== current$jscomp$0) {
-            var currentRef = current$jscomp$0.ref;
+          var current$$1$jscomp$0 = nextEffect.alternate;
+          if (null !== current$$1$jscomp$0) {
+            var currentRef = current$$1$jscomp$0.ref;
             null !== currentRef &&
               ("function" === typeof currentRef
                 ? currentRef(null)
@@ -4973,32 +5111,36 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
           case 8:
             prevState = nextEffect;
             a: for (snapshot = instance = prevState; ; ) {
-              latestPendingTime = snapshot;
-              "function" === typeof onCommitUnmount &&
-                onCommitUnmount(latestPendingTime);
-              switch (latestPendingTime.tag) {
+              childExpirationTimeBeforeCommit = snapshot;
+              "function" === typeof onCommitFiberUnmount &&
+                onCommitFiberUnmount(childExpirationTimeBeforeCommit);
+              switch (childExpirationTimeBeforeCommit.tag) {
                 case 2:
-                  safelyDetachRef(latestPendingTime);
-                  var instance$jscomp$0 = latestPendingTime.stateNode;
+                  safelyDetachRef(childExpirationTimeBeforeCommit);
+                  var instance$jscomp$0 =
+                    childExpirationTimeBeforeCommit.stateNode;
                   if (
                     "function" === typeof instance$jscomp$0.componentWillUnmount
                   )
                     try {
                       (instance$jscomp$0.props =
-                        latestPendingTime.memoizedProps),
+                        childExpirationTimeBeforeCommit.memoizedProps),
                         (instance$jscomp$0.state =
-                          latestPendingTime.memoizedState),
+                          childExpirationTimeBeforeCommit.memoizedState),
                         instance$jscomp$0.componentWillUnmount();
                     } catch (unmountError) {
-                      captureCommitPhaseError(latestPendingTime, unmountError);
+                      captureCommitPhaseError(
+                        childExpirationTimeBeforeCommit,
+                        unmountError
+                      );
                     }
                   break;
                 case 5:
-                  safelyDetachRef(latestPendingTime);
+                  safelyDetachRef(childExpirationTimeBeforeCommit);
                   break;
                 case 4:
                   FabricUIManager.createChildSet(
-                    latestPendingTime.stateNode.containerInfo
+                    childExpirationTimeBeforeCommit.stateNode.containerInfo
                   );
               }
               if (null !== snapshot.child)
@@ -5023,9 +5165,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (current = !0), (prevProps = e);
+      (current$$1 = !0), (prevProps = e);
     }
-    current &&
+    current$$1 &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5036,25 +5178,25 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
   root.current = finishedWork$jscomp$0;
   for (nextEffect = firstBatch; null !== nextEffect; ) {
     effectTag = !1;
-    current$jscomp$0 = void 0;
+    current$$1$jscomp$0 = void 0;
     try {
       for (currentRef = expirationTime; null !== nextEffect; ) {
         var effectTag$jscomp$0 = nextEffect.effectTag;
         if (effectTag$jscomp$0 & 36) {
-          var current$jscomp$1 = nextEffect.alternate;
+          var current$$1$jscomp$1 = nextEffect.alternate;
           instance$jscomp$0 = nextEffect;
           firstBatch = currentRef;
           switch (instance$jscomp$0.tag) {
             case 2:
               var instance$jscomp$1 = instance$jscomp$0.stateNode;
               if (instance$jscomp$0.effectTag & 4)
-                if (null === current$jscomp$1)
+                if (null === current$$1$jscomp$1)
                   (instance$jscomp$1.props = instance$jscomp$0.memoizedProps),
                     (instance$jscomp$1.state = instance$jscomp$0.memoizedState),
                     instance$jscomp$1.componentDidMount();
                 else {
-                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
-                    prevState$jscomp$0 = current$jscomp$1.memoizedState;
+                  var prevProps$jscomp$0 = current$$1$jscomp$1.memoizedProps,
+                    prevState$jscomp$0 = current$$1$jscomp$1.memoizedState;
                   instance$jscomp$1.props = instance$jscomp$0.memoizedProps;
                   instance$jscomp$1.state = instance$jscomp$0.memoizedState;
                   instance$jscomp$1.componentDidUpdate(
@@ -5077,25 +5219,25 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
             case 3:
               var _updateQueue = instance$jscomp$0.updateQueue;
               if (null !== _updateQueue) {
-                current = null;
+                current$$1 = null;
                 if (null !== instance$jscomp$0.child)
                   switch (instance$jscomp$0.child.tag) {
                     case 5:
-                      current = instance$jscomp$0.child.stateNode.canonical;
+                      current$$1 = instance$jscomp$0.child.stateNode.canonical;
                       break;
                     case 2:
-                      current = instance$jscomp$0.child.stateNode;
+                      current$$1 = instance$jscomp$0.child.stateNode;
                   }
                 commitUpdateQueue(
                   instance$jscomp$0,
                   _updateQueue,
-                  current,
+                  current$$1,
                   firstBatch
                 );
               }
               break;
             case 5:
-              null === current$jscomp$1 &&
+              null === current$$1$jscomp$1 &&
                 instance$jscomp$0.effectTag & 4 &&
                 invariant(
                   !1,
@@ -5139,31 +5281,37 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = next;
       }
     } catch (e) {
-      (effectTag = !0), (current$jscomp$0 = e);
+      (effectTag = !0), (current$$1$jscomp$0 = e);
     }
     effectTag &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
       ),
-      captureCommitPhaseError(nextEffect, current$jscomp$0),
+      captureCommitPhaseError(nextEffect, current$$1$jscomp$0),
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
   isWorking = isCommitting$1 = !1;
-  "function" === typeof onCommitRoot &&
-    onCommitRoot(finishedWork$jscomp$0.stateNode);
-  finishedWork$jscomp$0 = root.expirationTime;
+  "function" === typeof onCommitFiberRoot &&
+    onCommitFiberRoot(finishedWork$jscomp$0.stateNode);
+  effectTag$jscomp$0 = finishedWork$jscomp$0.expirationTime;
+  finishedWork$jscomp$0 = finishedWork$jscomp$0.childExpirationTime;
+  finishedWork$jscomp$0 =
+    0 === effectTag$jscomp$0 ||
+    (0 !== finishedWork$jscomp$0 && finishedWork$jscomp$0 < effectTag$jscomp$0)
+      ? finishedWork$jscomp$0
+      : effectTag$jscomp$0;
   0 === finishedWork$jscomp$0 &&
     (legacyErrorBoundariesThatAlreadyFailed = null);
   root.expirationTime = finishedWork$jscomp$0;
   root.finishedWork = null;
 }
 function shouldYield() {
-  return null === deadline ||
-    deadlineDidExpire ||
-    deadline.timeRemaining() > timeHeuristicForUnitOfWork
-    ? !1
-    : (deadlineDidExpire = !0);
+  return deadlineDidExpire
+    ? !0
+    : null === deadline || deadline.timeRemaining() > timeHeuristicForUnitOfWork
+      ? !1
+      : (deadlineDidExpire = !0);
 }
 function onUncaughtError(error) {
   invariant(
@@ -5180,7 +5328,7 @@ function updateContainerAtExpirationTime(
   expirationTime,
   callback
 ) {
-  var current = container.current;
+  var current$$1 = container.current;
   if (parentComponent) {
     parentComponent = parentComponent._reactInternalFiber;
     var parentContext;
@@ -5206,7 +5354,7 @@ function updateContainerAtExpirationTime(
     parentComponent = isContextProvider(parentComponent)
       ? processChildContext(parentComponent, parentContext)
       : parentContext;
-  } else parentComponent = emptyObject;
+  } else parentComponent = emptyContextObject;
   null === container.context
     ? (container.context = parentComponent)
     : (container.pendingContext = parentComponent);
@@ -5215,8 +5363,8 @@ function updateContainerAtExpirationTime(
   callback.payload = { element: element };
   container = void 0 === container ? null : container;
   null !== container && (callback.callback = container);
-  enqueueUpdate(current, callback, expirationTime);
-  scheduleWork(current, expirationTime);
+  enqueueUpdate(current$$1, callback);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 function findHostInstance$1(component) {
@@ -5233,14 +5381,14 @@ function findHostInstance$1(component) {
   return null === component ? null : component.stateNode;
 }
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    currentTime = recalculateCurrentTime();
-  current = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current,
+    currentTime = requestCurrentTime();
+  current$$1 = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
     parentComponent,
-    current,
+    current$$1,
     callback
   );
 }
@@ -5283,14 +5431,12 @@ var ReactFabricRenderer = {
     );
     nextFlushedRoot = root;
     nextFlushedExpirationTime = expirationTime;
-    performWorkOnRoot(root, expirationTime, !1);
+    performWorkOnRoot(root, expirationTime, !0);
     performWork(1, null);
-    finishRendering();
   },
   requestWork: requestWork,
   computeUniqueAsyncExpiration: function() {
-    var result =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var result = 2 + 25 * ((((requestCurrentTime() - 2 + 500) / 25) | 0) + 1);
     result <= lastUniqueAsyncExpiration &&
       (result = lastUniqueAsyncExpiration + 1);
     return (lastUniqueAsyncExpiration = result);
@@ -5318,9 +5464,9 @@ var ReactFabricRenderer = {
     return fn(a);
   },
   deferredUpdates: function(fn) {
-    var previousExpirationContext = expirationContext;
-    expirationContext =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var currentTime = requestCurrentTime(),
+      previousExpirationContext = expirationContext;
+    expirationContext = 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1);
     try {
       return fn();
     } finally {
@@ -5492,7 +5638,7 @@ var roots = new Map(),
               maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
             nativeProps = diffProperties(
               null,
-              emptyObject$1,
+              emptyObject,
               nativeProps,
               viewConfig.validAttributes
             );
@@ -5563,7 +5709,7 @@ var roots = new Map(),
               var viewConfig = maybeInstance.viewConfig;
               nativeProps = diffProperties(
                 null,
-                emptyObject$1,
+                emptyObject,
                 nativeProps,
                 viewConfig.validAttributes
               );
diff --git a/Libraries/Renderer/oss/ReactFabric-profiling.js b/Libraries/Renderer/oss/ReactFabric-profiling.js
index f19629787..33e0f44b7 100644
--- a/Libraries/Renderer/oss/ReactFabric-profiling.js
+++ b/Libraries/Renderer/oss/ReactFabric-profiling.js
@@ -12,16 +12,35 @@
 
 "use strict";
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant"),
-  ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
+var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
   UIManager = require("UIManager"),
   React = require("react"),
-  emptyObject = require("fbjs/lib/emptyObject"),
   deepDiffer = require("deepDiffer"),
   flattenStyle = require("flattenStyle"),
   TextInputState = require("TextInputState"),
   FabricUIManager = require("FabricUIManager"),
   ExceptionsManager = require("ExceptionsManager");
+function invariant(condition, format, a, b, c, d, e, f) {
+  if (!condition) {
+    condition = void 0;
+    if (void 0 === format)
+      condition = Error(
+        "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+      );
+    else {
+      var args = [a, b, c, d, e, f],
+        argIndex = 0;
+      condition = Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      condition.name = "Invariant Violation";
+    }
+    condition.framesToPop = 1;
+    throw condition;
+  }
+}
 function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = !1;
   this._caughtError = null;
@@ -347,9 +366,6 @@ function accumulateDirectDispatchesSingle(event) {
     }
   }
 }
-var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(
-  " "
-);
 function functionThatReturnsTrue() {
   return !0;
 }
@@ -407,12 +423,9 @@ Object.assign(SyntheticEvent.prototype, {
     var Interface = this.constructor.Interface,
       propName;
     for (propName in Interface) this[propName] = null;
-    for (
-      Interface = 0;
-      Interface < shouldBeReleasedProperties.length;
-      Interface++
-    )
-      this[shouldBeReleasedProperties[Interface]] = null;
+    this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+    this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+    this._dispatchInstances = this._dispatchListeners = null;
   }
 });
 SyntheticEvent.Interface = {
@@ -458,7 +471,7 @@ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
 function releasePooledEvent(event) {
   invariant(
     event instanceof this,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   10 > this.eventPool.length && this.eventPool.push(event);
@@ -615,7 +628,9 @@ function accumulate(current, next) {
     ? next
     : Array.isArray(current)
       ? current.concat(next)
-      : Array.isArray(next) ? [current].concat(next) : [current, next];
+      : Array.isArray(next)
+        ? [current].concat(next)
+        : [current, next];
 }
 var responderInst = null,
   trackedTouchCount = 0;
@@ -881,7 +896,9 @@ var eventTypes$1 = {
           ? eventTypes$1.responderStart
           : targetInst
             ? eventTypes$1.responderMove
-            : depthA ? eventTypes$1.responderEnd : null)
+            : depthA
+              ? eventTypes$1.responderEnd
+              : null)
       )
         (JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(
           JSCompiler_temp$jscomp$0,
@@ -935,7 +952,9 @@ var eventTypes$1 = {
       if (
         (topLevelType = JSCompiler_temp$jscomp$0
           ? eventTypes$1.responderTerminate
-          : topLevelType ? eventTypes$1.responderRelease : null)
+          : topLevelType
+            ? eventTypes$1.responderRelease
+            : null)
       )
         (nativeEvent = ResponderSyntheticEvent.getPooled(
           topLevelType,
@@ -1001,7 +1020,7 @@ injection.injectEventPluginsByName({
 function getInstanceFromInstance(instanceHandle) {
   return instanceHandle;
 }
-var Injected$jscomp$inline_574 = {
+var Injected$jscomp$inline_618 = {
   getClosestInstanceFromNode: getInstanceFromInstance,
   getInstanceFromNode: getInstanceFromInstance,
   getNodeFromInstance: function(inst) {
@@ -1014,9 +1033,9 @@ var Injected$jscomp$inline_574 = {
   }
 };
 getFiberCurrentPropsFromNode =
-  Injected$jscomp$inline_574.getFiberCurrentPropsFromNode;
-getInstanceFromNode = Injected$jscomp$inline_574.getInstanceFromNode;
-getNodeFromInstance = Injected$jscomp$inline_574.getNodeFromInstance;
+  Injected$jscomp$inline_618.getFiberCurrentPropsFromNode;
+getInstanceFromNode = Injected$jscomp$inline_618.getInstanceFromNode;
+getNodeFromInstance = Injected$jscomp$inline_618.getNodeFromInstance;
 ResponderEventPlugin.injection.injectGlobalResponderHandler({
   onChange: function(from, to, blockNativeResponder) {
     null !== to
@@ -1027,8 +1046,8 @@ ResponderEventPlugin.injection.injectGlobalResponderHandler({
       : UIManager.clearJSResponder();
   }
 });
-var ReactCurrentOwner =
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
+var ReactSharedInternals =
+    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
   hasSymbol = "function" === typeof Symbol && Symbol.for,
   REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103,
   REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106,
@@ -1039,7 +1058,7 @@ var ReactCurrentOwner =
   REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110,
   REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111,
   REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112,
-  REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 60113,
+  REACT_PLACEHOLDER_TYPE = hasSymbol ? Symbol.for("react.placeholder") : 60113,
   MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "undefined" === typeof maybeIterable)
@@ -1049,34 +1068,35 @@ function getIteratorFn(maybeIterable) {
     maybeIterable["@@iterator"];
   return "function" === typeof maybeIterable ? maybeIterable : null;
 }
-function getComponentName(fiber) {
-  var type = fiber.type;
-  if ("function" === typeof type) return type.displayName || type.name;
+function getComponentName(type) {
+  if (null == type) return null;
+  if ("function" === typeof type) return type.displayName || type.name || null;
   if ("string" === typeof type) return type;
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if ("object" === typeof type && null !== type)
+  if ("object" === typeof type)
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
         return (
-          (fiber = type.render.displayName || type.render.name || ""),
-          "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef"
+          (type = type.render),
+          (type = type.displayName || type.name || ""),
+          "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"
         );
     }
   return null;
@@ -1219,7 +1239,7 @@ function mountSafeCallback(context, callback) {
     }
   };
 }
-var emptyObject$1 = {},
+var emptyObject = {},
   removedKeys = null,
   removedKeyCount = 0;
 function restoreDeletedValuesInNestedArray(
@@ -1319,7 +1339,7 @@ function addNestedProperty(updatePayload, nextProp, validAttributes) {
   if (!Array.isArray(nextProp))
     return diffProperties(
       updatePayload,
-      emptyObject$1,
+      emptyObject,
       nextProp,
       validAttributes
     );
@@ -1337,7 +1357,7 @@ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
     return diffProperties(
       updatePayload,
       prevProp,
-      emptyObject$1,
+      emptyObject,
       validAttributes
     );
   for (var i = 0; i < prevProp.length; i++)
@@ -1570,7 +1590,7 @@ var ReactFabricHostComponent = (function() {
   ReactFabricHostComponent.prototype.setNativeProps = function(nativeProps) {
     nativeProps = diffProperties(
       null,
-      emptyObject$1,
+      emptyObject,
       nativeProps,
       this.viewConfig.validAttributes
     );
@@ -1605,7 +1625,7 @@ function createTextInstance(
     )
   };
 }
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   do {
     a: switch (workInProgress.tag) {
@@ -1613,11 +1633,12 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
       case 1:
       case 2:
       case 5:
+      case 11:
         var owner = workInProgress._debugOwner,
           source = workInProgress._debugSource;
-        var JSCompiler_inline_result = getComponentName(workInProgress);
+        var JSCompiler_inline_result = getComponentName(workInProgress.type);
         var ownerName = null;
-        owner && (ownerName = getComponentName(owner));
+        owner && (ownerName = getComponentName(owner.type));
         owner = source;
         JSCompiler_inline_result =
           "\n    in " +
@@ -1628,7 +1649,9 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
               ":" +
               owner.lineNumber +
               ")"
-            : ownerName ? " (created by " + ownerName + ")" : "");
+            : ownerName
+              ? " (created by " + ownerName + ")"
+              : "");
         break a;
       default:
         JSCompiler_inline_result = "";
@@ -1641,9 +1664,6 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
 new Set();
 var valueStack = [],
   index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
-}
 function pop(cursor) {
   0 > index ||
     ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
@@ -1653,9 +1673,10 @@ function push(cursor, value) {
   valueStack[index] = cursor.current;
   cursor.current = value;
 }
-var contextStackCursor = createCursor(emptyObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyObject;
+var emptyContextObject = {},
+  contextStackCursor = { current: emptyContextObject },
+  didPerformWorkStackCursor = { current: !1 },
+  previousContext = emptyContextObject;
 function getUnmaskedContext(workInProgress) {
   return isContextProvider(workInProgress)
     ? previousContext
@@ -1663,7 +1684,7 @@ function getUnmaskedContext(workInProgress) {
 }
 function getMaskedContext(workInProgress, unmaskedContext) {
   var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyObject;
+  if (!contextTypes) return emptyContextObject;
   var instance = workInProgress.stateNode;
   if (
     instance &&
@@ -1692,15 +1713,16 @@ function popTopLevelContextObject(fiber) {
 }
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "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(fiber, parentContext) {
-  var instance = fiber.stateNode,
-    childContextTypes = fiber.type.childContextTypes;
+  var instance = fiber.stateNode;
+  fiber = fiber.type;
+  var childContextTypes = fiber.childContextTypes;
   if ("function" !== typeof instance.getChildContext) return parentContext;
   instance = instance.getChildContext();
   for (var contextKey in instance)
@@ -1717,7 +1739,7 @@ function pushContextProvider(workInProgress) {
   var instance = workInProgress.stateNode;
   instance =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
   previousContext = contextStackCursor.current;
   push(contextStackCursor, instance, workInProgress);
   push(
@@ -1742,6 +1764,31 @@ function invalidateContextProvider(workInProgress, didChange) {
   } else pop(didPerformWorkStackCursor, workInProgress);
   push(didPerformWorkStackCursor, didChange, workInProgress);
 }
+var onCommitFiberRoot = null,
+  onCommitFiberUnmount = null;
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {}
+  };
+}
+var isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__;
+function injectInternals(internals) {
+  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled || !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 FiberNode(tag, pendingProps, key, mode) {
   this.tag = tag;
   this.key = key;
@@ -1749,13 +1796,13 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.index = 0;
   this.ref = null;
   this.pendingProps = pendingProps;
-  this.memoizedState = this.updateQueue = this.memoizedProps = null;
+  this.firstContextDependency = this.memoizedState = this.updateQueue = this.memoizedProps = null;
   this.mode = mode;
   this.effectTag = 0;
   this.lastEffect = this.firstEffect = this.nextEffect = null;
-  this.expirationTime = 0;
+  this.childExpirationTime = this.expirationTime = 0;
   this.alternate = null;
-  this.treeBaseTime = this.selfBaseTime = this.actualStartTime = this.actualDuration = 0;
+  this.treeBaseDuration = this.selfBaseDuration = this.actualStartTime = this.actualDuration = 0;
 }
 function createWorkInProgress(current, pendingProps, expirationTime) {
   var workInProgress = current.alternate;
@@ -1777,16 +1824,21 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
       (workInProgress.lastEffect = null),
       (workInProgress.actualDuration = 0),
       (workInProgress.actualStartTime = 0));
-  workInProgress.expirationTime = expirationTime;
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  workInProgress.expirationTime =
+    pendingProps !== current.pendingProps
+      ? expirationTime
+      : current.expirationTime;
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
   workInProgress.sibling = current.sibling;
   workInProgress.index = current.index;
   workInProgress.ref = current.ref;
-  workInProgress.selfBaseTime = current.selfBaseTime;
-  workInProgress.treeBaseTime = current.treeBaseTime;
+  workInProgress.selfBaseDuration = current.selfBaseDuration;
+  workInProgress.treeBaseDuration = current.treeBaseDuration;
   return workInProgress;
 }
 function createFiberFromElement(element, mode, expirationTime) {
@@ -1820,15 +1872,14 @@ function createFiberFromElement(element, mode, expirationTime) {
           (type.expirationTime = expirationTime),
           type
         );
-      case REACT_TIMEOUT_TYPE:
+      case REACT_PLACEHOLDER_TYPE:
         fiberTag = 16;
-        mode |= 2;
         break;
       default:
         a: {
-          switch ("object" === typeof type && null !== type
-            ? type.$$typeof
-            : null) {
+          switch (
+            "object" === typeof type && null !== type ? type.$$typeof : null
+          ) {
             case REACT_PROVIDER_TYPE:
               fiberTag = 13;
               break a;
@@ -1880,7 +1931,9 @@ function createFiberFromPortal(portal, mode, expirationTime) {
   return mode;
 }
 function createFiberRoot(containerInfo, isAsync, hydrate) {
-  isAsync = new FiberNode(3, null, null, isAsync ? 3 : 0);
+  isAsync = isAsync ? 3 : 0;
+  isDevToolsPresent && (isAsync |= 4);
+  isAsync = new FiberNode(3, null, null, isAsync);
   containerInfo = {
     current: isAsync,
     containerInfo: containerInfo,
@@ -1893,6 +1946,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
     didError: !1,
     pendingCommitExpirationTime: 0,
     finishedWork: null,
+    timeoutHandle: -1,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -1903,36 +1957,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   };
   return (isAsync.stateNode = containerInfo);
 }
-var onCommitFiberRoot = null,
-  onCommitFiberUnmount = null;
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {}
-  };
-}
-function injectInternals(internals) {
-  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled || !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(root) {
-  "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
-}
-function onCommitUnmount(fiber) {
-  "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
-}
 function markPendingPriorityLevel(root, expirationTime) {
   root.didError = !1;
   var earliestPendingTime = root.earliestPendingTime;
@@ -1942,30 +1966,30 @@ function markPendingPriorityLevel(root, expirationTime) {
       ? (root.earliestPendingTime = expirationTime)
       : root.latestPendingTime < expirationTime &&
         (root.latestPendingTime = expirationTime);
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
-function findNextPendingPriorityLevel(root) {
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
   var earliestSuspendedTime = root.earliestSuspendedTime,
-    earliestPendingTime = root.earliestPendingTime;
-  if (0 === earliestSuspendedTime)
-    var nextExpirationTimeToWorkOn = (earliestSuspendedTime = earliestPendingTime);
-  else
-    0 !== earliestPendingTime
-      ? ((nextExpirationTimeToWorkOn = earliestPendingTime),
-        (earliestSuspendedTime =
-          earliestSuspendedTime < earliestPendingTime
-            ? earliestSuspendedTime
-            : earliestPendingTime))
-      : (nextExpirationTimeToWorkOn = earliestSuspendedTime =
-          root.latestPingedTime);
-  root.didError && (earliestSuspendedTime = 1);
-  root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
-  root.expirationTime = earliestSuspendedTime;
+    latestSuspendedTime = root.latestSuspendedTime,
+    earliestPendingTime = root.earliestPendingTime,
+    latestPingedTime = root.latestPingedTime;
+  earliestPendingTime =
+    0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+  0 === earliestPendingTime &&
+    (0 === completedExpirationTime ||
+      latestSuspendedTime > completedExpirationTime) &&
+    (earliestPendingTime = latestSuspendedTime);
+  completedExpirationTime = earliestPendingTime;
+  0 !== completedExpirationTime &&
+    0 !== earliestSuspendedTime &&
+    earliestSuspendedTime < completedExpirationTime &&
+    (completedExpirationTime = earliestSuspendedTime);
+  root.nextExpirationTimeToWorkOn = earliestPendingTime;
+  root.expirationTime = completedExpirationTime;
 }
 var hasForceUpdate = !1;
 function createUpdateQueue(baseState) {
   return {
-    expirationTime: 0,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -1979,7 +2003,6 @@ function createUpdateQueue(baseState) {
 }
 function cloneUpdateQueue(currentQueue) {
   return {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -2001,14 +2024,12 @@ function createUpdate(expirationTime) {
     nextEffect: null
   };
 }
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   null === queue.lastUpdate
     ? (queue.firstUpdate = queue.lastUpdate = update)
     : ((queue.lastUpdate.next = update), (queue.lastUpdate = update));
-  if (0 === queue.expirationTime || queue.expirationTime > expirationTime)
-    queue.expirationTime = expirationTime;
 }
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   var alternate = fiber.alternate;
   if (null === alternate) {
     var queue1 = fiber.updateQueue;
@@ -2030,14 +2051,13 @@ function enqueueUpdate(fiber, update, expirationTime) {
         : null === queue2 &&
           (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
   null === queue2 || queue1 === queue2
-    ? appendUpdateToQueue(queue1, update, expirationTime)
+    ? appendUpdateToQueue(queue1, update)
     : null === queue1.lastUpdate || null === queue2.lastUpdate
-      ? (appendUpdateToQueue(queue1, update, expirationTime),
-        appendUpdateToQueue(queue2, update, expirationTime))
-      : (appendUpdateToQueue(queue1, update, expirationTime),
-        (queue2.lastUpdate = update));
+      ? (appendUpdateToQueue(queue1, update),
+        appendUpdateToQueue(queue2, update))
+      : (appendUpdateToQueue(queue1, update), (queue2.lastUpdate = update));
 }
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   var workInProgressQueue = workInProgress.updateQueue;
   workInProgressQueue =
     null === workInProgressQueue
@@ -2049,11 +2069,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     ? (workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update)
     : ((workInProgressQueue.lastCapturedUpdate.next = update),
       (workInProgressQueue.lastCapturedUpdate = update));
-  if (
-    0 === workInProgressQueue.expirationTime ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  )
-    workInProgressQueue.expirationTime = renderExpirationTime;
 }
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
   var current = workInProgress.alternate;
@@ -2101,87 +2116,83 @@ function processUpdateQueue(
   renderExpirationTime
 ) {
   hasForceUpdate = !1;
-  if (
-    !(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)
-  ) {
-    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
-    for (
-      var newBaseState = queue.baseState,
-        newFirstUpdate = null,
-        newExpirationTime = 0,
-        update = queue.firstUpdate,
-        resultState = newBaseState;
-      null !== update;
+  queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+  for (
+    var newBaseState = queue.baseState,
+      newFirstUpdate = null,
+      newExpirationTime = 0,
+      update = queue.firstUpdate,
+      resultState = newBaseState;
+    null !== update;
 
-    ) {
-      var updateExpirationTime = update.expirationTime;
-      if (updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === newFirstUpdate &&
-            ((newFirstUpdate = update), (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > updateExpirationTime)
-        )
-          newExpirationTime = updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastEffect
-              ? (queue.firstEffect = queue.lastEffect = update)
-              : ((queue.lastEffect.nextEffect = update),
-                (queue.lastEffect = update)));
-      update = update.next;
-    }
-    updateExpirationTime = null;
-    for (update = queue.firstCapturedUpdate; null !== update; ) {
-      var _updateExpirationTime = update.expirationTime;
-      if (_updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === updateExpirationTime &&
-            ((updateExpirationTime = update),
-            null === newFirstUpdate && (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
-        )
-          newExpirationTime = _updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastCapturedEffect
-              ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
-              : ((queue.lastCapturedEffect.nextEffect = update),
-                (queue.lastCapturedEffect = update)));
-      update = update.next;
-    }
-    null === newFirstUpdate && (queue.lastUpdate = null);
-    null === updateExpirationTime
-      ? (queue.lastCapturedUpdate = null)
-      : (workInProgress.effectTag |= 32);
-    null === newFirstUpdate &&
-      null === updateExpirationTime &&
-      (newBaseState = resultState);
-    queue.baseState = newBaseState;
-    queue.firstUpdate = newFirstUpdate;
-    queue.firstCapturedUpdate = updateExpirationTime;
-    queue.expirationTime = newExpirationTime;
-    workInProgress.memoizedState = resultState;
+  ) {
+    var updateExpirationTime = update.expirationTime;
+    if (updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === newFirstUpdate &&
+          ((newFirstUpdate = update), (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > updateExpirationTime)
+      )
+        newExpirationTime = updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastEffect
+            ? (queue.firstEffect = queue.lastEffect = update)
+            : ((queue.lastEffect.nextEffect = update),
+              (queue.lastEffect = update)));
+    update = update.next;
   }
+  updateExpirationTime = null;
+  for (update = queue.firstCapturedUpdate; null !== update; ) {
+    var _updateExpirationTime = update.expirationTime;
+    if (_updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === updateExpirationTime &&
+          ((updateExpirationTime = update),
+          null === newFirstUpdate && (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
+      )
+        newExpirationTime = _updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastCapturedEffect
+            ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
+            : ((queue.lastCapturedEffect.nextEffect = update),
+              (queue.lastCapturedEffect = update)));
+    update = update.next;
+  }
+  null === newFirstUpdate && (queue.lastUpdate = null);
+  null === updateExpirationTime
+    ? (queue.lastCapturedUpdate = null)
+    : (workInProgress.effectTag |= 32);
+  null === newFirstUpdate &&
+    null === updateExpirationTime &&
+    (newBaseState = resultState);
+  queue.baseState = newBaseState;
+  queue.firstUpdate = newFirstUpdate;
+  queue.firstCapturedUpdate = updateExpirationTime;
+  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.memoizedState = resultState;
 }
 function callCallback(callback, context) {
   invariant(
@@ -2223,34 +2234,153 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
-var providerCursor = createCursor(null),
-  valueCursor = createCursor(null),
-  changedBitsCursor = createCursor(0);
+var valueCursor = { current: null },
+  changedBitsCursor = { current: 0 },
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastContextWithAllBitsObserved = null;
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
   push(changedBitsCursor, context._changedBits2, providerFiber);
   push(valueCursor, context._currentValue2, providerFiber);
-  push(providerCursor, providerFiber, providerFiber);
   context._currentValue2 = providerFiber.pendingProps.value;
   context._changedBits2 = providerFiber.stateNode;
 }
 function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current,
     currentValue = valueCursor.current;
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
   providerFiber = providerFiber.type._context;
   providerFiber._currentValue2 = currentValue;
   providerFiber._changedBits2 = changedBits;
 }
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  null !== fiber && (fiber.return = workInProgress);
+  for (; null !== fiber; ) {
+    var dependency = fiber.firstContextDependency;
+    if (null !== dependency) {
+      do {
+        if (
+          dependency.context === context &&
+          0 !== (dependency.observedBits & changedBits)
+        ) {
+          if (
+            0 === fiber.expirationTime ||
+            fiber.expirationTime > renderExpirationTime
+          )
+            fiber.expirationTime = renderExpirationTime;
+          var nextFiber = fiber.alternate;
+          null !== nextFiber &&
+            (0 === nextFiber.expirationTime ||
+              nextFiber.expirationTime > renderExpirationTime) &&
+            (nextFiber.expirationTime = renderExpirationTime);
+          for (var node = fiber.return; null !== node; ) {
+            nextFiber = node.alternate;
+            if (
+              0 === node.childExpirationTime ||
+              node.childExpirationTime > renderExpirationTime
+            )
+              (node.childExpirationTime = renderExpirationTime),
+                null !== nextFiber &&
+                  (0 === nextFiber.childExpirationTime ||
+                    nextFiber.childExpirationTime > renderExpirationTime) &&
+                  (nextFiber.childExpirationTime = renderExpirationTime);
+            else if (
+              null !== nextFiber &&
+              (0 === nextFiber.childExpirationTime ||
+                nextFiber.childExpirationTime > renderExpirationTime)
+            )
+              nextFiber.childExpirationTime = renderExpirationTime;
+            else break;
+            node = node.return;
+          }
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        dependency = dependency.next;
+      } while (null !== dependency);
+    } else
+      nextFiber =
+        13 === fiber.tag
+          ? fiber.type === workInProgress.type
+            ? null
+            : fiber.child
+          : fiber.child;
+    if (null !== nextFiber) nextFiber.return = fiber;
+    else
+      for (nextFiber = fiber; null !== nextFiber; ) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+    fiber = nextFiber;
+  }
+}
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextWithAllBitsObserved = lastContextDependency = null;
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (null !== firstContextDependency) {
+    workInProgress.firstContextDependency = null;
+    var hasPendingContext = !1;
+    do {
+      var _context = firstContextDependency.context,
+        changedBits = _context._changedBits2;
+      0 !== changedBits &&
+        (propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        ),
+        0 !== (changedBits & firstContextDependency.observedBits) &&
+          (hasPendingContext = !0));
+      firstContextDependency = firstContextDependency.next;
+    } while (null !== firstContextDependency);
+    return hasPendingContext;
+  }
+  return !1;
+}
+function readContext(context, observedBits) {
+  if (
+    lastContextWithAllBitsObserved !== context &&
+    !1 !== observedBits &&
+    0 !== observedBits
+  ) {
+    if ("number" !== typeof observedBits || 1073741823 === observedBits)
+      (lastContextWithAllBitsObserved = context), (observedBits = 1073741823);
+    observedBits = { context: context, observedBits: observedBits, next: null };
+    null === lastContextDependency
+      ? (invariant(
+          null !== currentlyRenderingFiber,
+          "Context.unstable_read(): Context can only be read while React is rendering, e.g. inside the render method or getDerivedStateFromProps."
+        ),
+        (currentlyRenderingFiber.firstContextDependency = lastContextDependency = observedBits))
+      : (lastContextDependency = lastContextDependency.next = observedBits);
+  }
+  return context._currentValue2;
+}
 var NO_CONTEXT = {},
-  contextStackCursor$1 = createCursor(NO_CONTEXT),
-  contextFiberStackCursor = createCursor(NO_CONTEXT),
-  rootInstanceStackCursor = createCursor(NO_CONTEXT);
+  contextStackCursor$1 = { current: NO_CONTEXT },
+  contextFiberStackCursor = { current: NO_CONTEXT },
+  rootInstanceStackCursor = { current: NO_CONTEXT };
 function requiredContext(c) {
   invariant(
     c !== NO_CONTEXT,
@@ -2270,16 +2400,45 @@ function popHostContainer(fiber) {
   pop(contextFiberStackCursor, fiber);
   pop(rootInstanceStackCursor, fiber);
 }
+function pushHostContext(fiber) {
+  requiredContext(rootInstanceStackCursor.current);
+  var context = requiredContext(contextStackCursor$1.current);
+  var nextContext = fiber.type;
+  nextContext =
+    "AndroidTextInput" === nextContext ||
+    "RCTMultilineTextInputView" === nextContext ||
+    "RCTSinglelineTextInputView" === nextContext ||
+    "RCTText" === nextContext ||
+    "RCTVirtualText" === nextContext;
+  nextContext =
+    context.isInAParentText !== nextContext
+      ? { isInAParentText: nextContext }
+      : context;
+  context !== nextContext &&
+    (push(contextFiberStackCursor, fiber, fiber),
+    push(contextStackCursor$1, nextContext, fiber));
+}
 function popHostContext(fiber) {
   contextFiberStackCursor.current === fiber &&
     (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
 }
-var timerPausedAt = 0,
+var syncCommitStartTime = 0,
+  timerPausedAt = 0,
   totalElapsedPauseTime = 0;
+function pauseActualRenderTimerIfRunning() {
+  0 === timerPausedAt && (timerPausedAt = now$1());
+  0 < syncCommitStartTime
+    ? ((totalElapsedPauseTime += now$1() - syncCommitStartTime),
+      (syncCommitStartTime = 0))
+    : (totalElapsedPauseTime = 0);
+}
 function recordElapsedActualRenderTime(fiber) {
   fiber.actualDuration = now$1() - totalElapsedPauseTime - fiber.actualDuration;
 }
-function resumeActualRenderTimerIfPaused() {
+function resumeActualRenderTimerIfPaused(isProcessingSyncWork) {
+  isProcessingSyncWork &&
+    0 === syncCommitStartTime &&
+    (syncCommitStartTime = now$1());
   0 < timerPausedAt &&
     ((totalElapsedPauseTime += now$1() - timerPausedAt), (timerPausedAt = 0));
 }
@@ -2308,6 +2467,7 @@ function shallowEqual(objA, objB) {
       return !1;
   return !0;
 }
+var emptyRefsObject = new React.Component().refs;
 function applyDerivedStateFromProps(
   workInProgress,
   getDerivedStateFromProps,
@@ -2320,10 +2480,10 @@ function applyDerivedStateFromProps(
       ? prevState
       : Object.assign({}, prevState, getDerivedStateFromProps);
   workInProgress.memoizedState = prevState;
-  workInProgress = workInProgress.updateQueue;
-  null !== workInProgress &&
+  getDerivedStateFromProps = workInProgress.updateQueue;
+  null !== getDerivedStateFromProps &&
     0 === workInProgress.expirationTime &&
-    (workInProgress.baseState = prevState);
+    (getDerivedStateFromProps.baseState = prevState);
 }
 var classComponentUpdater = {
   isMounted: function(component) {
@@ -2333,33 +2493,33 @@ var classComponentUpdater = {
   },
   enqueueSetState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 1;
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 2;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   }
 };
@@ -2369,12 +2529,12 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   workInProgress = workInProgress.type;
   return "function" === typeof instance.shouldComponentUpdate
-    ? instance.shouldComponentUpdate(newProps, newState, newContext)
+    ? instance.shouldComponentUpdate(newProps, newState, nextLegacyContext)
     : workInProgress.prototype && workInProgress.prototype.isPureReactComponent
       ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
       : !0;
@@ -2383,13 +2543,13 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   workInProgress = instance.state;
   "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   instance.state !== workInProgress &&
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
@@ -2400,7 +2560,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     unmaskedContext = getUnmaskedContext(workInProgress);
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
   unmaskedContext = workInProgress.updateQueue;
   null !== unmaskedContext &&
@@ -2412,7 +2572,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
       renderExpirationTime
     ),
     (instance.state = workInProgress.memoizedState));
-  unmaskedContext = workInProgress.type.getDerivedStateFromProps;
+  unmaskedContext = ctor.getDerivedStateFromProps;
   "function" === typeof unmaskedContext &&
     (applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
     (instance.state = workInProgress.memoizedState));
@@ -2441,7 +2601,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     (workInProgress.effectTag |= 4);
 }
 var isArray$1 = Array.isArray;
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   returnFiber = element.ref;
   if (
     null !== returnFiber &&
@@ -2464,18 +2624,19 @@ function coerceRef(returnFiber, current, element) {
       );
       var stringRef = "" + returnFiber;
       if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
+        null !== current$$1 &&
+        null !== current$$1.ref &&
+        "function" === typeof current$$1.ref &&
+        current$$1.ref._stringRef === stringRef
       )
-        return current.ref;
-      current = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        return current$$1.ref;
+      current$$1 = function(value) {
+        var refs = inst.refs;
+        refs === emptyRefsObject && (refs = inst.refs = {});
         null === value ? delete refs[stringRef] : (refs[stringRef] = value);
       };
-      current._stringRef = stringRef;
-      return current;
+      current$$1._stringRef = stringRef;
+      return current$$1;
     }
     invariant(
       "string" === typeof returnFiber,
@@ -2553,26 +2714,31 @@ function ChildReconciler(shouldTrackSideEffects) {
       (newFiber.effectTag = 2);
     return newFiber;
   }
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (null === current || 6 !== current.tag)
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (null === current$$1 || 6 !== current$$1.tag)
       return (
-        (current = createFiberFromText(
+        (current$$1 = createFiberFromText(
           textContent,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, textContent, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, textContent, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (null !== current && current.type === element.type)
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (null !== current$$1 && current$$1.type === element.type)
       return (
-        (expirationTime = useFiber(current, element.props, expirationTime)),
-        (expirationTime.ref = coerceRef(returnFiber, current, element)),
+        (expirationTime = useFiber(current$$1, element.props, expirationTime)),
+        (expirationTime.ref = coerceRef(returnFiber, current$$1, element)),
         (expirationTime.return = returnFiber),
         expirationTime
       );
@@ -2581,45 +2747,51 @@ function ChildReconciler(shouldTrackSideEffects) {
       returnFiber.mode,
       expirationTime
     );
-    expirationTime.ref = coerceRef(returnFiber, current, element);
+    expirationTime.ref = coerceRef(returnFiber, current$$1, element);
     expirationTime.return = returnFiber;
     return expirationTime;
   }
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      null === current$$1 ||
+      4 !== current$$1.tag ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     )
       return (
-        (current = createFiberFromPortal(
+        (current$$1 = createFiberFromPortal(
           portal,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, portal.children || [], expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (null === current || 10 !== current.tag)
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (null === current$$1 || 10 !== current$$1.tag)
       return (
-        (current = createFiberFromFragment(
+        (current$$1 = createFiberFromFragment(
           fragment,
           returnFiber.mode,
           expirationTime,
           key
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, fragment, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, fragment, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
   function createChild(returnFiber, newChild, expirationTime) {
     if ("string" === typeof newChild || "number" === typeof newChild)
@@ -3185,22 +3357,15 @@ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
         (hydrationParentFiber = fiber$jscomp$0);
   }
 }
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-function reconcileChildrenAtExpirationTime(
-  current,
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
   workInProgress.child =
-    null === current
+    null === current$$1
       ? mountChildFibers(
           workInProgress,
           null,
@@ -3209,50 +3374,50 @@ function reconcileChildrenAtExpirationTime(
         )
       : reconcileChildFibers(
           workInProgress,
-          current.child,
+          current$$1.child,
           nextChildren,
           renderExpirationTime
         );
 }
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
+    (null === current$$1 && null !== ref) ||
+    (null !== current$$1 && current$$1.ref !== ref)
   )
     workInProgress.effectTag |= 128;
 }
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
   var didCaptureError = 0 !== (workInProgress.effectTag & 64);
   if (!shouldUpdate && !didCaptureError)
     return (
       hasContext && invalidateContextProvider(workInProgress, !1),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
+      bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      )
     );
   shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   if (didCaptureError) {
     var nextChildren = null;
     baseStartTime = -1;
   } else nextChildren = shouldUpdate.render();
   workInProgress.effectTag |= 1;
-  didCaptureError &&
-    (reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    ),
+  null !== current$$1 &&
+    didCaptureError &&
+    (reconcileChildren(current$$1, workInProgress, null, renderExpirationTime),
     (workInProgress.child = null));
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -3274,170 +3439,62 @@ function pushHostRootContext(workInProgress) {
       pushTopLevelContextObject(workInProgress, root.context, !1);
   pushHostContainer(workInProgress, root.containerInfo);
 }
-function propagateContextChange(
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  null !== fiber && (fiber.return = workInProgress);
-  for (; null !== fiber; ) {
-    switch (fiber.tag) {
-      case 12:
-        var nextFiber = fiber.stateNode | 0;
-        if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
-          for (nextFiber = fiber; null !== nextFiber; ) {
-            var alternate = nextFiber.alternate;
-            if (
-              0 === nextFiber.expirationTime ||
-              nextFiber.expirationTime > renderExpirationTime
-            )
-              (nextFiber.expirationTime = renderExpirationTime),
-                null !== alternate &&
-                  (0 === alternate.expirationTime ||
-                    alternate.expirationTime > renderExpirationTime) &&
-                  (alternate.expirationTime = renderExpirationTime);
-            else if (
-              null !== alternate &&
-              (0 === alternate.expirationTime ||
-                alternate.expirationTime > renderExpirationTime)
-            )
-              alternate.expirationTime = renderExpirationTime;
-            else break;
-            nextFiber = nextFiber.return;
-          }
-          nextFiber = null;
-        } else nextFiber = fiber.child;
-        break;
-      case 13:
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        nextFiber = fiber.child;
-    }
-    if (null !== nextFiber) nextFiber.return = fiber;
-    else
-      for (nextFiber = fiber; null !== nextFiber; ) {
-        if (nextFiber === workInProgress) {
-          nextFiber = null;
-          break;
-        }
-        fiber = nextFiber.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
-        }
-        nextFiber = nextFiber.return;
-      }
-    fiber = nextFiber;
-  }
-}
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
-  var context = workInProgress.type._context,
-    newProps = workInProgress.pendingProps,
-    oldProps = workInProgress.memoizedProps,
-    canBailOnProps = !0;
-  if (didPerformWorkStackCursor.current) canBailOnProps = !1;
-  else if (oldProps === newProps)
-    return (
-      (workInProgress.stateNode = 0),
-      pushProvider(workInProgress),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
-    );
-  var newValue = newProps.value;
-  workInProgress.memoizedProps = newProps;
-  if (null === oldProps) newValue = 1073741823;
-  else if (oldProps.value === newProps.value) {
-    if (oldProps.children === newProps.children && canBailOnProps)
-      return (
-        (workInProgress.stateNode = 0),
-        pushProvider(workInProgress),
-        bailoutOnAlreadyFinishedWork(current, workInProgress)
-      );
-    newValue = 0;
-  } else {
-    var oldValue = oldProps.value;
-    if (
-      (oldValue === newValue &&
-        (0 !== oldValue || 1 / oldValue === 1 / newValue)) ||
-      (oldValue !== oldValue && newValue !== newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-      newValue = 0;
-    } else if (
-      ((newValue =
-        "function" === typeof context._calculateChangedBits
-          ? context._calculateChangedBits(oldValue, newValue)
-          : 1073741823),
-      (newValue |= 0),
-      0 === newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-    } else
-      propagateContextChange(
-        workInProgress,
-        context,
-        newValue,
-        renderExpirationTime
-      );
-  }
-  workInProgress.stateNode = newValue;
-  pushProvider(workInProgress);
-  reconcileChildren(current, workInProgress, newProps.children);
-  return workInProgress.child;
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+  null !== current$$1 &&
+    (workInProgress.firstContextDependency = current$$1.firstContextDependency);
   baseStartTime = -1;
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (0 === childExpirationTime || childExpirationTime > renderExpirationTime)
+    return null;
   invariant(
-    null === current || workInProgress.child === current.child,
+    null === current$$1 || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
   if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    var newChild = createWorkInProgress(
-      current,
-      current.pendingProps,
-      current.expirationTime
+    current$$1 = workInProgress.child;
+    renderExpirationTime = createWorkInProgress(
+      current$$1,
+      current$$1.pendingProps,
+      current$$1.expirationTime
     );
-    workInProgress.child = newChild;
-    for (newChild.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (newChild = newChild.sibling = createWorkInProgress(
-          current,
-          current.pendingProps,
-          current.expirationTime
+    workInProgress.child = renderExpirationTime;
+    for (
+      renderExpirationTime.return = workInProgress;
+      null !== current$$1.sibling;
+
+    )
+      (current$$1 = current$$1.sibling),
+        (renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(
+          current$$1,
+          current$$1.pendingProps,
+          current$$1.expirationTime
         )),
-        (newChild.return = workInProgress);
-    newChild.sibling = null;
+        (renderExpirationTime.return = workInProgress);
+    renderExpirationTime.sibling = null;
   }
   return workInProgress.child;
 }
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
   workInProgress.mode & 4 &&
     ((workInProgress.actualDuration =
       now$1() - workInProgress.actualDuration - totalElapsedPauseTime),
     (workInProgress.actualStartTime = now$1()));
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    0 === workInProgress.expirationTime ||
-    workInProgress.expirationTime > renderExpirationTime
+    !didPerformWorkStackCursor.current &&
+    (0 === updateExpirationTime || updateExpirationTime > renderExpirationTime)
   ) {
-    baseStartTime = -1;
     switch (workInProgress.tag) {
       case 3:
         pushHostRootContext(workInProgress);
         break;
+      case 5:
+        pushHostContext(workInProgress);
+        break;
       case 2:
         pushContextProvider(workInProgress);
         break;
@@ -3448,21 +3505,31 @@ function beginWork(current, workInProgress, renderExpirationTime) {
         );
         break;
       case 13:
+        workInProgress.stateNode = 0;
         pushProvider(workInProgress);
+        break;
+      case 15:
+        workInProgress.effectTag |= 4;
     }
-    return null;
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
+  workInProgress.expirationTime = 0;
   switch (workInProgress.tag) {
     case 0:
       invariant(
-        null === current,
+        null === current$$1,
         "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue."
       );
-      var fn = workInProgress.type,
-        props = workInProgress.pendingProps,
-        unmaskedContext = getUnmaskedContext(workInProgress);
+      var fn = workInProgress.type;
+      updateExpirationTime = workInProgress.pendingProps;
+      var unmaskedContext = getUnmaskedContext(workInProgress);
       unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
-      fn = fn(props, unmaskedContext);
+      prepareToReadContext(workInProgress, renderExpirationTime);
+      fn = fn(updateExpirationTime, unmaskedContext);
       workInProgress.effectTag |= 1;
       "object" === typeof fn &&
       null !== fn &&
@@ -3474,45 +3541,52 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null !== fn.state && void 0 !== fn.state ? fn.state : null),
           (unmaskedContext = unmaskedContext.getDerivedStateFromProps),
           "function" === typeof unmaskedContext &&
-            applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
-          (props = pushContextProvider(workInProgress)),
+            applyDerivedStateFromProps(
+              workInProgress,
+              unmaskedContext,
+              updateExpirationTime
+            ),
+          (updateExpirationTime = pushContextProvider(workInProgress)),
           (fn.updater = classComponentUpdater),
           (workInProgress.stateNode = fn),
           (fn._reactInternalFiber = workInProgress),
           mountClassInstance(workInProgress, renderExpirationTime),
-          (current = finishClassComponent(
-            current,
+          (current$$1 = finishClassComponent(
+            current$$1,
             workInProgress,
             !0,
-            props,
+            updateExpirationTime,
             renderExpirationTime
           )))
         : ((workInProgress.tag = 1),
-          reconcileChildren(current, workInProgress, fn),
-          (workInProgress.memoizedProps = props),
-          (current = workInProgress.child));
-      return current;
+          reconcileChildren(
+            current$$1,
+            workInProgress,
+            fn,
+            renderExpirationTime
+          ),
+          (workInProgress.memoizedProps = updateExpirationTime),
+          (current$$1 = workInProgress.child));
+      return current$$1;
     case 1:
       return (
-        (props = workInProgress.type),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? ((fn = getUnmaskedContext(workInProgress)),
-            (fn = getMaskedContext(workInProgress, fn)),
-            (props = props(renderExpirationTime, fn)),
-            (workInProgress.effectTag |= 1),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (fn = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = getUnmaskedContext(workInProgress)),
+        (unmaskedContext = getMaskedContext(workInProgress, unmaskedContext)),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (fn = fn(updateExpirationTime, unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 2:
-      props = pushContextProvider(workInProgress);
-      if (null === current)
+      updateExpirationTime = pushContextProvider(workInProgress);
+      fn = prepareToReadContext(workInProgress, renderExpirationTime);
+      if (null === current$$1)
         if (null === workInProgress.stateNode) {
-          var props$jscomp$0 = workInProgress.pendingProps,
+          var props = workInProgress.pendingProps,
             ctor = workInProgress.type;
           fn = getUnmaskedContext(workInProgress);
           var needsContext =
@@ -3520,15 +3594,13 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null != workInProgress.type.contextTypes;
           unmaskedContext = needsContext
             ? getMaskedContext(workInProgress, fn)
-            : emptyObject;
-          props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
+            : emptyContextObject;
+          props = new ctor(props, unmaskedContext);
           workInProgress.memoizedState =
-            null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state
-              ? props$jscomp$0.state
-              : null;
-          props$jscomp$0.updater = classComponentUpdater;
-          workInProgress.stateNode = props$jscomp$0;
-          props$jscomp$0._reactInternalFiber = workInProgress;
+            null !== props.state && void 0 !== props.state ? props.state : null;
+          props.updater = classComponentUpdater;
+          workInProgress.stateNode = props;
+          props._reactInternalFiber = workInProgress;
           needsContext &&
             ((needsContext = workInProgress.stateNode),
             (needsContext.__reactInternalMemoizedUnmaskedChildContext = fn),
@@ -3536,122 +3608,46 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           mountClassInstance(workInProgress, renderExpirationTime);
           fn = !0;
         } else {
-          ctor = workInProgress.type;
-          fn = workInProgress.stateNode;
-          needsContext = workInProgress.memoizedProps;
-          unmaskedContext = workInProgress.pendingProps;
-          fn.props = needsContext;
-          var oldContext = fn.context;
-          props$jscomp$0 = getUnmaskedContext(workInProgress);
-          props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
-          var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-          (ctor =
+          var ctor$jscomp$0 = workInProgress.type;
+          unmaskedContext = workInProgress.stateNode;
+          props = workInProgress.memoizedProps;
+          needsContext = workInProgress.pendingProps;
+          unmaskedContext.props = props;
+          var oldContext = unmaskedContext.context;
+          ctor = getUnmaskedContext(workInProgress);
+          ctor = getMaskedContext(workInProgress, ctor);
+          var getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps;
+          (ctor$jscomp$0 =
             "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((needsContext !== unmaskedContext ||
-              oldContext !== props$jscomp$0) &&
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((props !== needsContext || oldContext !== ctor) &&
               callComponentWillReceiveProps(
                 workInProgress,
-                fn,
                 unmaskedContext,
-                props$jscomp$0
+                needsContext,
+                ctor
               ));
           hasForceUpdate = !1;
           var oldState = workInProgress.memoizedState;
-          oldContext = fn.state = oldState;
+          oldContext = unmaskedContext.state = oldState;
           var updateQueue = workInProgress.updateQueue;
           null !== updateQueue &&
             (processUpdateQueue(
               workInProgress,
               updateQueue,
+              needsContext,
               unmaskedContext,
-              fn,
               renderExpirationTime
             ),
             (oldContext = workInProgress.memoizedState));
-          needsContext !== unmaskedContext ||
+          props !== needsContext ||
           oldState !== oldContext ||
           didPerformWorkStackCursor.current ||
-          hasForceUpdate
-            ? ("function" === typeof getDerivedStateFromProps &&
-                (applyDerivedStateFromProps(
-                  workInProgress,
-                  getDerivedStateFromProps,
-                  unmaskedContext
-                ),
-                (oldContext = workInProgress.memoizedState)),
-              (needsContext =
-                hasForceUpdate ||
-                checkShouldComponentUpdate(
-                  workInProgress,
-                  needsContext,
-                  unmaskedContext,
-                  oldState,
-                  oldContext,
-                  props$jscomp$0
-                ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillMount &&
-                      "function" !== typeof fn.componentWillMount) ||
-                    ("function" === typeof fn.componentWillMount &&
-                      fn.componentWillMount(),
-                    "function" === typeof fn.UNSAFE_componentWillMount &&
-                      fn.UNSAFE_componentWillMount()),
-                  "function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4))
-                : ("function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4),
-                  (workInProgress.memoizedProps = unmaskedContext),
-                  (workInProgress.memoizedState = oldContext)),
-              (fn.props = unmaskedContext),
-              (fn.state = oldContext),
-              (fn.context = props$jscomp$0),
-              (fn = needsContext))
-            : ("function" === typeof fn.componentDidMount &&
-                (workInProgress.effectTag |= 4),
-              (fn = !1));
-        }
-      else
-        (ctor = workInProgress.type),
-          (fn = workInProgress.stateNode),
-          (unmaskedContext = workInProgress.memoizedProps),
-          (needsContext = workInProgress.pendingProps),
-          (fn.props = unmaskedContext),
-          (oldContext = fn.context),
-          (props$jscomp$0 = getUnmaskedContext(workInProgress)),
-          (props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0)),
-          (getDerivedStateFromProps = ctor.getDerivedStateFromProps),
-          (ctor =
-            "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((unmaskedContext !== needsContext ||
-              oldContext !== props$jscomp$0) &&
-              callComponentWillReceiveProps(
-                workInProgress,
-                fn,
-                needsContext,
-                props$jscomp$0
-              )),
-          (hasForceUpdate = !1),
-          (oldContext = workInProgress.memoizedState),
-          (oldState = fn.state = oldContext),
-          (updateQueue = workInProgress.updateQueue),
-          null !== updateQueue &&
-            (processUpdateQueue(
-              workInProgress,
-              updateQueue,
-              needsContext,
-              fn,
-              renderExpirationTime
-            ),
-            (oldState = workInProgress.memoizedState)),
-          unmaskedContext !== needsContext ||
-          oldContext !== oldState ||
-          didPerformWorkStackCursor.current ||
+          fn ||
           hasForceUpdate
             ? ("function" === typeof getDerivedStateFromProps &&
                 (applyDerivedStateFromProps(
@@ -3659,128 +3655,203 @@ function beginWork(current, workInProgress, renderExpirationTime) {
                   getDerivedStateFromProps,
                   needsContext
                 ),
-                (oldState = workInProgress.memoizedState)),
-              (getDerivedStateFromProps =
+                (oldContext = workInProgress.memoizedState)),
+              (fn =
                 hasForceUpdate ||
+                fn ||
                 checkShouldComponentUpdate(
                   workInProgress,
-                  unmaskedContext,
+                  props,
                   needsContext,
+                  oldState,
+                  oldContext,
+                  ctor
+                ))
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillMount) ||
+                    ("function" === typeof unmaskedContext.componentWillMount &&
+                      unmaskedContext.componentWillMount(),
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      unmaskedContext.UNSAFE_componentWillMount()),
+                  "function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4))
+                : ("function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4),
+                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedState = oldContext)),
+              (unmaskedContext.props = needsContext),
+              (unmaskedContext.state = oldContext),
+              (unmaskedContext.context = ctor))
+            : ("function" === typeof unmaskedContext.componentDidMount &&
+                (workInProgress.effectTag |= 4),
+              (fn = !1));
+        }
+      else
+        (ctor$jscomp$0 = workInProgress.type),
+          (unmaskedContext = workInProgress.stateNode),
+          (needsContext = workInProgress.memoizedProps),
+          (props = workInProgress.pendingProps),
+          (unmaskedContext.props = needsContext),
+          (oldContext = unmaskedContext.context),
+          (ctor = getUnmaskedContext(workInProgress)),
+          (ctor = getMaskedContext(workInProgress, ctor)),
+          (getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps),
+          (ctor$jscomp$0 =
+            "function" === typeof getDerivedStateFromProps ||
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((needsContext !== props || oldContext !== ctor) &&
+              callComponentWillReceiveProps(
+                workInProgress,
+                unmaskedContext,
+                props,
+                ctor
+              )),
+          (hasForceUpdate = !1),
+          (oldContext = workInProgress.memoizedState),
+          (oldState = unmaskedContext.state = oldContext),
+          (updateQueue = workInProgress.updateQueue),
+          null !== updateQueue &&
+            (processUpdateQueue(
+              workInProgress,
+              updateQueue,
+              props,
+              unmaskedContext,
+              renderExpirationTime
+            ),
+            (oldState = workInProgress.memoizedState)),
+          needsContext !== props ||
+          oldContext !== oldState ||
+          didPerformWorkStackCursor.current ||
+          fn ||
+          hasForceUpdate
+            ? ("function" === typeof getDerivedStateFromProps &&
+                (applyDerivedStateFromProps(
+                  workInProgress,
+                  getDerivedStateFromProps,
+                  props
+                ),
+                (oldState = workInProgress.memoizedState)),
+              (fn =
+                hasForceUpdate ||
+                fn ||
+                checkShouldComponentUpdate(
+                  workInProgress,
+                  needsContext,
+                  props,
                   oldContext,
                   oldState,
-                  props$jscomp$0
+                  ctor
                 ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillUpdate &&
-                      "function" !== typeof fn.componentWillUpdate) ||
-                    ("function" === typeof fn.componentWillUpdate &&
-                      fn.componentWillUpdate(
-                        needsContext,
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillUpdate) ||
+                    ("function" ===
+                      typeof unmaskedContext.componentWillUpdate &&
+                      unmaskedContext.componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       ),
-                    "function" === typeof fn.UNSAFE_componentWillUpdate &&
-                      fn.UNSAFE_componentWillUpdate(
-                        needsContext,
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      unmaskedContext.UNSAFE_componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       )),
-                  "function" === typeof fn.componentDidUpdate &&
+                  "function" === typeof unmaskedContext.componentDidUpdate &&
                     (workInProgress.effectTag |= 4),
-                  "function" === typeof fn.getSnapshotBeforeUpdate &&
+                  "function" ===
+                    typeof unmaskedContext.getSnapshotBeforeUpdate &&
                     (workInProgress.effectTag |= 256))
-                : ("function" !== typeof fn.componentDidUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 4),
-                  "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                  "function" !==
+                    typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 256),
-                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedProps = props),
                   (workInProgress.memoizedState = oldState)),
-              (fn.props = needsContext),
-              (fn.state = oldState),
-              (fn.context = props$jscomp$0),
-              (fn = getDerivedStateFromProps))
-            : ("function" !== typeof fn.componentDidUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              (unmaskedContext.props = props),
+              (unmaskedContext.state = oldState),
+              (unmaskedContext.context = ctor))
+            : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 4),
-              "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              "function" !== typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 256),
               (fn = !1));
       return finishClassComponent(
-        current,
+        current$$1,
         workInProgress,
         fn,
-        props,
+        updateExpirationTime,
         renderExpirationTime
       );
     case 3:
       return (
         pushHostRootContext(workInProgress),
-        (props = workInProgress.updateQueue),
-        null !== props
-          ? ((fn = workInProgress.memoizedState),
-            (fn = null !== fn ? fn.element : null),
-            processUpdateQueue(
+        (updateExpirationTime = workInProgress.updateQueue),
+        invariant(
+          null !== updateExpirationTime,
+          "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."
+        ),
+        (fn = workInProgress.memoizedState),
+        (fn = null !== fn ? fn.element : null),
+        processUpdateQueue(
+          workInProgress,
+          updateExpirationTime,
+          workInProgress.pendingProps,
+          null,
+          renderExpirationTime
+        ),
+        (updateExpirationTime = workInProgress.memoizedState.element),
+        updateExpirationTime === fn
+          ? (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
               workInProgress,
-              props,
-              workInProgress.pendingProps,
-              null,
+              renderExpirationTime
+            ))
+          : (reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
               renderExpirationTime
             ),
-            (renderExpirationTime = workInProgress.memoizedState.element),
-            renderExpirationTime === fn
-              ? (current = bailoutOnAlreadyFinishedWork(
-                  current,
-                  workInProgress
-                ))
-              : (reconcileChildren(
-                  current,
-                  workInProgress,
-                  renderExpirationTime
-                ),
-                (current = workInProgress.child)))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+            (current$$1 = workInProgress.child)),
+        current$$1
       );
     case 5:
       return (
-        requiredContext(rootInstanceStackCursor.current),
-        (renderExpirationTime = requiredContext(contextStackCursor$1.current)),
-        (props = workInProgress.type),
-        (props =
-          "AndroidTextInput" === props ||
-          "RCTMultilineTextInputView" === props ||
-          "RCTSinglelineTextInputView" === props ||
-          "RCTText" === props ||
-          "RCTVirtualText" === props),
-        (props =
-          renderExpirationTime.isInAParentText !== props
-            ? { isInAParentText: props }
-            : renderExpirationTime),
-        renderExpirationTime !== props &&
-          (push(contextFiberStackCursor, workInProgress, workInProgress),
-          push(contextStackCursor$1, props, workInProgress)),
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
-        (props = workInProgress.memoizedProps),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current || props !== renderExpirationTime
-          ? ((props = renderExpirationTime.children),
-            markRef(current, workInProgress),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        pushHostContext(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        markRef(current$$1, workInProgress),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        (current$$1 = workInProgress.child),
+        current$$1
       );
     case 6:
       return (
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
         (workInProgress.memoizedProps = workInProgress.pendingProps),
         null
       );
@@ -3792,114 +3863,182 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           workInProgress,
           workInProgress.stateNode.containerInfo
         ),
-        (props = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== props
-          ? (null === current
-              ? (workInProgress.child = reconcileChildFibers(
-                  workInProgress,
-                  null,
-                  props,
-                  renderExpirationTime
-                ))
-              : reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = props),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        null === current$$1
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              updateExpirationTime,
+              renderExpirationTime
+            ))
+          : reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
+              renderExpirationTime
+            ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 14:
       return (
-        (props = workInProgress.type.render),
-        (renderExpirationTime = workInProgress.pendingProps),
-        (fn = workInProgress.ref),
+        (fn = workInProgress.type.render),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = workInProgress.ref),
         didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime ||
-        fn !== (null !== current ? current.ref : null)
-          ? ((props = props(renderExpirationTime, fn)),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        workInProgress.memoizedProps !== updateExpirationTime ||
+        unmaskedContext !== (null !== current$$1 ? current$$1.ref : null)
+          ? ((fn = fn(updateExpirationTime, unmaskedContext)),
+            reconcileChildren(
+              current$$1,
+              workInProgress,
+              fn,
+              renderExpirationTime
+            ),
+            (workInProgress.memoizedProps = updateExpirationTime),
+            (current$$1 = workInProgress.child))
+          : (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            )),
+        current$$1
       );
     case 10:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 11:
       return (
-        (renderExpirationTime = workInProgress.pendingProps.children),
-        didPerformWorkStackCursor.current ||
-        (null !== renderExpirationTime &&
-          workInProgress.memoizedProps !== renderExpirationTime)
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps.children),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 15:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
         (workInProgress.effectTag |= 4),
-        workInProgress.memoizedProps === renderExpirationTime
-          ? (current = bailoutOnAlreadyFinishedWork(current, workInProgress))
-          : (reconcileChildren(
-              current,
-              workInProgress,
-              renderExpirationTime.children
-            ),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime.children,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 13:
-      return updateContextProvider(
-        current,
-        workInProgress,
-        renderExpirationTime
-      );
-    case 12:
-      a: if (
-        ((fn = workInProgress.type),
-        (unmaskedContext = workInProgress.pendingProps),
-        (needsContext = workInProgress.memoizedProps),
-        (props = fn._currentValue2),
-        (props$jscomp$0 = fn._changedBits2),
-        didPerformWorkStackCursor.current ||
-          0 !== props$jscomp$0 ||
-          needsContext !== unmaskedContext)
-      ) {
-        workInProgress.memoizedProps = unmaskedContext;
-        ctor = unmaskedContext.unstable_observedBits;
-        if (void 0 === ctor || null === ctor) ctor = 1073741823;
-        workInProgress.stateNode = ctor;
-        if (0 !== (props$jscomp$0 & ctor))
+      a: {
+        updateExpirationTime = workInProgress.type._context;
+        fn = workInProgress.pendingProps;
+        unmaskedContext = workInProgress.memoizedProps;
+        needsContext = fn.value;
+        workInProgress.memoizedProps = fn;
+        if (null === unmaskedContext) needsContext = 1073741823;
+        else if (unmaskedContext.value === fn.value) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((props = unmaskedContext.value),
+          (props === needsContext &&
+            (0 !== props || 1 / props === 1 / needsContext)) ||
+            (props !== props && needsContext !== needsContext))
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((needsContext =
+            "function" === typeof updateExpirationTime._calculateChangedBits
+              ? updateExpirationTime._calculateChangedBits(props, needsContext)
+              : 1073741823),
+          (needsContext |= 0),
+          0 === needsContext)
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+        } else
           propagateContextChange(
             workInProgress,
-            fn,
-            props$jscomp$0,
+            updateExpirationTime,
+            needsContext,
             renderExpirationTime
           );
-        else if (needsContext === unmaskedContext) {
-          current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-          break a;
-        }
-        renderExpirationTime = unmaskedContext.children;
-        renderExpirationTime = renderExpirationTime(props);
-        workInProgress.effectTag |= 1;
-        reconcileChildren(current, workInProgress, renderExpirationTime);
-        current = workInProgress.child;
-      } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-      return current;
+        workInProgress.stateNode = needsContext;
+        pushProvider(workInProgress);
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          fn.children,
+          renderExpirationTime
+        );
+        current$$1 = workInProgress.child;
+      }
+      return current$$1;
+    case 12:
+      return (
+        (unmaskedContext = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (unmaskedContext = readContext(
+          unmaskedContext,
+          updateExpirationTime.unstable_observedBits
+        )),
+        (fn = fn(unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
+      );
     default:
       invariant(
         !1,
@@ -3997,161 +4136,16 @@ updateHostText$1 = function(current, workInProgress, oldText, newText) {
     )),
     (workInProgress.effectTag |= 4));
 };
-function completeWork(current, workInProgress) {
-  var newProps = workInProgress.pendingProps;
-  workInProgress.mode & 4 && recordElapsedActualRenderTime(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return null;
-    case 2:
-      return popContextProvider(workInProgress), null;
-    case 3:
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      newProps = workInProgress.stateNode;
-      newProps.pendingContext &&
-        ((newProps.context = newProps.pendingContext),
-        (newProps.pendingContext = null));
-      if (null === current || null === current.child)
-        workInProgress.effectTag &= -3;
-      updateHostContainer(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      var rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        ),
-        type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode) {
-        var oldProps = current.memoizedProps,
-          instance = workInProgress.stateNode,
-          currentHostContext = requiredContext(contextStackCursor$1.current),
-          updatePayload = diffProperties(
-            null,
-            oldProps,
-            newProps,
-            instance.canonical.viewConfig.validAttributes
-          );
-        instance.canonical.currentProps = newProps;
-        updateHostComponent$1(
-          current,
-          workInProgress,
-          updatePayload,
-          type,
-          oldProps,
-          newProps,
-          rootContainerInstance,
-          currentHostContext
-        );
-        current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      } 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
-          );
-        instance = requiredContext(contextStackCursor$1.current);
-        current = nextReactTag;
-        nextReactTag += 2;
-        oldProps = ReactNativeViewConfigRegistry.get(type);
-        invariant(
-          "RCTView" !== type || !instance.isInAParentText,
-          "Nesting of <View> within <Text> is not currently supported."
-        );
-        type = diffProperties(
-          null,
-          emptyObject$1,
-          newProps,
-          oldProps.validAttributes
-        );
-        rootContainerInstance = FabricUIManager.createNode(
-          current,
-          oldProps.uiViewClassName,
-          rootContainerInstance,
-          type,
-          workInProgress
-        );
-        newProps = new ReactFabricHostComponent(current, oldProps, newProps);
-        newProps = { node: rootContainerInstance, canonical: newProps };
-        appendAllChildren(newProps, workInProgress);
-        workInProgress.stateNode = newProps;
-        null !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      }
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        updateHostText$1(
-          current,
-          workInProgress,
-          current.memoizedProps,
-          newProps
-        );
-      else {
-        if ("string" !== typeof 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
-          );
-        rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        );
-        type = requiredContext(contextStackCursor$1.current);
-        workInProgress.stateNode = createTextInstance(
-          newProps,
-          rootContainerInstance,
-          type,
-          workInProgress
-        );
-      }
-      return null;
-    case 14:
-      return null;
-    case 16:
-      return null;
-    case 10:
-      return null;
-    case 11:
-      return null;
-    case 15:
-      return null;
-    case 4:
-      return (
-        popHostContainer(workInProgress),
-        updateHostContainer(workInProgress),
-        null
-      );
-    case 13:
-      return popProvider(workInProgress), null;
-    case 12:
-      return null;
-    case 0:
-      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."
-      );
-  }
-}
 function logError(boundary, errorInfo) {
   var source = errorInfo.source,
     stack = errorInfo.stack;
   null === stack &&
     null !== source &&
-    (stack = getStackAddendumByWorkInProgressFiber(source));
-  null !== source && getComponentName(source);
+    (stack = getStackByFiberInDevAndProd(source));
+  null !== source && getComponentName(source.type);
   source = null !== stack ? stack : "";
   errorInfo = errorInfo.value;
-  null !== boundary && 2 === boundary.tag && getComponentName(boundary);
+  null !== boundary && 2 === boundary.tag && getComponentName(boundary.type);
   try {
     if (errorInfo instanceof Error) {
       var message = errorInfo.message,
@@ -4173,18 +4167,18 @@ function logError(boundary, errorInfo) {
     (e && e.suppressReactErrorLogging) || console.error(e);
   }
 }
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (null !== ref)
     if ("function" === typeof ref)
       try {
         ref(null);
       } catch (refError) {
-        captureCommitPhaseError(current, refError);
+        captureCommitPhaseError(current$$1, refError);
       }
     else ref.current = null;
 }
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case 2:
       break;
@@ -4247,10 +4241,12 @@ function unwindWork(workInProgress) {
         popHostContainer(workInProgress),
         popTopLevelContextObject(workInProgress),
         (effectTag = workInProgress.effectTag),
-        effectTag & 1024
-          ? ((workInProgress.effectTag = (effectTag & -1025) | 64),
-            workInProgress)
-          : null
+        invariant(
+          0 === (effectTag & 64),
+          "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."
+        ),
+        (workInProgress.effectTag = (effectTag & -1025) | 64),
+        workInProgress
       );
     case 5:
       return popHostContext(workInProgress), null;
@@ -4270,16 +4266,14 @@ function unwindWork(workInProgress) {
       return null;
   }
 }
-var originalStartTimeMs = now$1(),
-  mostRecentCurrentTime = 2,
-  mostRecentCurrentTimeMs = originalStartTimeMs,
+var Dispatcher = { readContext: readContext },
+  ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
   lastUniqueAsyncExpiration = 0,
   expirationContext = 0,
   isWorking = !1,
   nextUnitOfWork = null,
   nextRoot = null,
   nextRenderExpirationTime = 0,
-  nextLatestTimeoutMs = -1,
   nextRenderDidError = !1,
   nextEffect = null,
   isCommitting$1 = !1,
@@ -4291,10 +4285,10 @@ function resetStack() {
       null !== interruptedWork;
 
     ) {
+      interruptedWork.mode & 4 && resumeActualRenderTimerIfPaused(!1);
       var interruptedWork$jscomp$0 = interruptedWork;
       interruptedWork$jscomp$0.mode & 4 &&
-        (resumeActualRenderTimerIfPaused(),
-        recordElapsedActualRenderTime(interruptedWork$jscomp$0));
+        recordElapsedActualRenderTime(interruptedWork$jscomp$0);
       switch (interruptedWork$jscomp$0.tag) {
         case 2:
           popContextProvider(interruptedWork$jscomp$0);
@@ -4316,129 +4310,261 @@ function resetStack() {
     }
   nextRoot = null;
   nextRenderExpirationTime = 0;
-  nextLatestTimeoutMs = -1;
   nextRenderDidError = !1;
   nextUnitOfWork = null;
 }
-function completeUnitOfWork(workInProgress$jscomp$0) {
+function completeUnitOfWork(workInProgress) {
   for (;;) {
-    var current = workInProgress$jscomp$0.alternate,
-      returnFiber = workInProgress$jscomp$0.return,
-      siblingFiber = workInProgress$jscomp$0.sibling;
-    if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
-      current = completeWork(
-        current,
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      var workInProgress = workInProgress$jscomp$0;
+    var current$$1 = workInProgress.alternate,
+      returnFiber = workInProgress.return,
+      siblingFiber = workInProgress.sibling;
+    if (0 === (workInProgress.effectTag & 512)) {
+      var current = current$$1;
+      current$$1 = workInProgress;
+      var newProps = current$$1.pendingProps;
+      switch (current$$1.tag) {
+        case 1:
+          break;
+        case 2:
+          popContextProvider(current$$1);
+          break;
+        case 3:
+          popHostContainer(current$$1);
+          popTopLevelContextObject(current$$1);
+          var fiberRoot = current$$1.stateNode;
+          fiberRoot.pendingContext &&
+            ((fiberRoot.context = fiberRoot.pendingContext),
+            (fiberRoot.pendingContext = null));
+          if (null === current || null === current.child)
+            current$$1.effectTag &= -3;
+          updateHostContainer(current$$1);
+          break;
+        case 5:
+          popHostContext(current$$1);
+          fiberRoot = requiredContext(rootInstanceStackCursor.current);
+          var type = current$$1.type;
+          if (null !== current && null != current$$1.stateNode) {
+            var oldProps = current.memoizedProps,
+              instance = current$$1.stateNode,
+              currentHostContext = requiredContext(
+                contextStackCursor$1.current
+              ),
+              newProps$jscomp$0 = newProps,
+              updatePayload = diffProperties(
+                null,
+                oldProps,
+                newProps$jscomp$0,
+                instance.canonical.viewConfig.validAttributes
+              );
+            instance.canonical.currentProps = newProps$jscomp$0;
+            updateHostComponent$1(
+              current,
+              current$$1,
+              updatePayload,
+              type,
+              oldProps,
+              newProps,
+              fiberRoot,
+              currentHostContext
+            );
+            current.ref !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else
+            newProps
+              ? ((oldProps = requiredContext(contextStackCursor$1.current)),
+                (current = newProps),
+                (instance = oldProps),
+                (currentHostContext = current$$1),
+                (newProps = nextReactTag),
+                (nextReactTag += 2),
+                (oldProps = ReactNativeViewConfigRegistry.get(type)),
+                invariant(
+                  "RCTView" !== type || !instance.isInAParentText,
+                  "Nesting of <View> within <Text> is not currently supported."
+                ),
+                (type = diffProperties(
+                  null,
+                  emptyObject,
+                  current,
+                  oldProps.validAttributes
+                )),
+                (fiberRoot = FabricUIManager.createNode(
+                  newProps,
+                  oldProps.uiViewClassName,
+                  fiberRoot,
+                  type,
+                  currentHostContext
+                )),
+                (current = new ReactFabricHostComponent(
+                  newProps,
+                  oldProps,
+                  current
+                )),
+                (fiberRoot = { node: fiberRoot, canonical: current }),
+                appendAllChildren(fiberRoot, current$$1),
+                (current$$1.stateNode = fiberRoot),
+                null !== current$$1.ref && (current$$1.effectTag |= 128))
+              : invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                );
+          break;
+        case 6:
+          fiberRoot = newProps;
+          current && null != current$$1.stateNode
+            ? updateHostText$1(
+                current,
+                current$$1,
+                current.memoizedProps,
+                fiberRoot
+              )
+            : ("string" !== typeof fiberRoot &&
+                invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                ),
+              (current = requiredContext(rootInstanceStackCursor.current)),
+              (newProps = requiredContext(contextStackCursor$1.current)),
+              (current$$1.stateNode = createTextInstance(
+                fiberRoot,
+                current,
+                newProps,
+                current$$1
+              )));
+          break;
+        case 14:
+          break;
+        case 16:
+          break;
+        case 10:
+          break;
+        case 11:
+          break;
+        case 15:
+          break;
+        case 4:
+          popHostContainer(current$$1);
+          updateHostContainer(current$$1);
+          break;
+        case 13:
+          popProvider(current$$1);
+          break;
+        case 12:
+          break;
+        case 0:
+          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."
+          );
+      }
+      current$$1.mode & 4 && recordElapsedActualRenderTime(current$$1);
+      current$$1 = nextUnitOfWork = null;
+      fiberRoot = workInProgress;
       if (
         1073741823 === nextRenderExpirationTime ||
-        1073741823 !== workInProgress.expirationTime
+        1073741823 !== fiberRoot.childExpirationTime
       ) {
-        var newExpirationTime = 0;
-        switch (workInProgress.tag) {
-          case 3:
-          case 2:
-            var updateQueue = workInProgress.updateQueue;
-            null !== updateQueue &&
-              (newExpirationTime = updateQueue.expirationTime);
-        }
-        if (workInProgress.mode & 4) {
-          updateQueue = workInProgress.selfBaseTime;
-          for (var child = workInProgress.child; null !== child; )
-            (updateQueue += child.treeBaseTime),
-              0 !== child.expirationTime &&
-                (0 === newExpirationTime ||
-                  newExpirationTime > child.expirationTime) &&
-                (newExpirationTime = child.expirationTime),
-              (child = child.sibling);
-          workInProgress.treeBaseTime = updateQueue;
+        current = 0;
+        if (fiberRoot.mode & 4) {
+          newProps = fiberRoot.selfBaseDuration;
+          for (type = fiberRoot.child; null !== type; ) {
+            oldProps = type.expirationTime;
+            currentHostContext = type.childExpirationTime;
+            if (0 === current || (0 !== oldProps && oldProps < current))
+              current = oldProps;
+            if (
+              0 === current ||
+              (0 !== currentHostContext && currentHostContext < current)
+            )
+              current = currentHostContext;
+            newProps += type.treeBaseDuration;
+            type = type.sibling;
+          }
+          fiberRoot.treeBaseDuration = newProps;
         } else
-          for (updateQueue = workInProgress.child; null !== updateQueue; )
-            0 !== updateQueue.expirationTime &&
-              (0 === newExpirationTime ||
-                newExpirationTime > updateQueue.expirationTime) &&
-              (newExpirationTime = updateQueue.expirationTime),
-              (updateQueue = updateQueue.sibling);
-        workInProgress.expirationTime = newExpirationTime;
+          for (newProps = fiberRoot.child; null !== newProps; ) {
+            type = newProps.expirationTime;
+            oldProps = newProps.childExpirationTime;
+            if (0 === current || (0 !== type && type < current)) current = type;
+            if (0 === current || (0 !== oldProps && oldProps < current))
+              current = oldProps;
+            newProps = newProps.sibling;
+          }
+        fiberRoot.childExpirationTime = current;
       }
-      if (null !== current) return current;
+      if (null !== current$$1) return current$$1;
       null !== returnFiber &&
         0 === (returnFiber.effectTag & 512) &&
         (null === returnFiber.firstEffect &&
-          (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect),
-        null !== workInProgress$jscomp$0.lastEffect &&
+          (returnFiber.firstEffect = workInProgress.firstEffect),
+        null !== workInProgress.lastEffect &&
           (null !== returnFiber.lastEffect &&
-            (returnFiber.lastEffect.nextEffect =
-              workInProgress$jscomp$0.firstEffect),
-          (returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect)),
-        1 < workInProgress$jscomp$0.effectTag &&
+            (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect),
+          (returnFiber.lastEffect = workInProgress.lastEffect)),
+        1 < workInProgress.effectTag &&
           (null !== returnFiber.lastEffect
-            ? (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0)
-            : (returnFiber.firstEffect = workInProgress$jscomp$0),
-          (returnFiber.lastEffect = workInProgress$jscomp$0)));
+            ? (returnFiber.lastEffect.nextEffect = workInProgress)
+            : (returnFiber.firstEffect = workInProgress),
+          (returnFiber.lastEffect = workInProgress)));
     } else {
-      workInProgress$jscomp$0 = unwindWork(
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      if (null !== workInProgress$jscomp$0)
-        return (
-          (workInProgress$jscomp$0.effectTag &= 511), workInProgress$jscomp$0
-        );
+      workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+      if (null !== workInProgress)
+        return (workInProgress.effectTag &= 511), workInProgress;
       null !== returnFiber &&
         ((returnFiber.firstEffect = returnFiber.lastEffect = null),
         (returnFiber.effectTag |= 512));
     }
     if (null !== siblingFiber) return siblingFiber;
-    if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;
+    if (null !== returnFiber) workInProgress = returnFiber;
     else break;
   }
   return null;
 }
 function performUnitOfWork(workInProgress) {
-  var current = workInProgress.alternate;
+  var current$$1 = workInProgress.alternate;
   workInProgress.mode & 4 && (baseStartTime = now$1());
-  current = beginWork(current, workInProgress, nextRenderExpirationTime);
+  current$$1 = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
   workInProgress.mode & 4 &&
     (-1 !== baseStartTime &&
-      (workInProgress.selfBaseTime = now$1() - baseStartTime),
+      (workInProgress.selfBaseDuration = now$1() - baseStartTime),
     (baseStartTime = -1));
-  null === current && (current = completeUnitOfWork(workInProgress));
-  ReactCurrentOwner.current = null;
-  return current;
+  null === current$$1 && (current$$1 = completeUnitOfWork(workInProgress));
+  ReactCurrentOwner$2.current = null;
+  return current$$1;
 }
-function renderRoot(root$jscomp$0, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isWorking = !0;
-  var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
+  var expirationTime = root.nextExpirationTimeToWorkOn;
   if (
     expirationTime !== nextRenderExpirationTime ||
-    root$jscomp$0 !== nextRoot ||
+    root !== nextRoot ||
     null === nextUnitOfWork
   )
     resetStack(),
-      (nextRoot = root$jscomp$0),
+      (nextRoot = root),
       (nextRenderExpirationTime = expirationTime),
-      (nextLatestTimeoutMs = -1),
-      (nextRenderDidError = !1),
       (nextUnitOfWork = createWorkInProgress(
         nextRoot.current,
         null,
         nextRenderExpirationTime
       )),
-      (root$jscomp$0.pendingCommitExpirationTime = 0);
+      (root.pendingCommitExpirationTime = 0);
   var didFatal = !1;
   do {
     try {
       if (isYieldy) {
         for (; null !== nextUnitOfWork && !shouldYield(); )
           nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
-        0 === timerPausedAt && (timerPausedAt = now$1());
+        pauseActualRenderTimerIfRunning();
       } else
         for (; null !== nextUnitOfWork; )
           nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
@@ -4450,110 +4576,117 @@ function renderRoot(root$jscomp$0, isYieldy) {
           null !== nextUnitOfWork,
           "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it."
         );
-        isYieldy = nextUnitOfWork;
-        var returnFiber = isYieldy.return;
-        if (null === returnFiber) {
-          didFatal = !0;
-          onUncaughtError(thrownValue);
-          break;
-        }
-        a: {
-          var root = root$jscomp$0,
-            returnFiber$jscomp$0 = returnFiber,
-            sourceFiber = isYieldy,
-            value = thrownValue;
-          returnFiber = nextRenderExpirationTime;
-          sourceFiber.effectTag |= 512;
-          sourceFiber.firstEffect = sourceFiber.lastEffect = null;
-          nextRenderDidError = !0;
-          if (
-            (root.didError || 1 === returnFiber) &&
-            (returnFiber === root.latestPendingTime ||
-              returnFiber === root.latestSuspendedTime)
-          ) {
-            value = createCapturedValue(value, sourceFiber);
-            root = returnFiber$jscomp$0;
+        var sourceFiber = nextUnitOfWork,
+          returnFiber = sourceFiber.return;
+        if (null === returnFiber) (didFatal = !0), onUncaughtError(thrownValue);
+        else {
+          a: {
+            var returnFiber$jscomp$0 = returnFiber,
+              sourceFiber$jscomp$0 = sourceFiber,
+              value = thrownValue;
+            returnFiber = nextRenderExpirationTime;
+            sourceFiber$jscomp$0.effectTag |= 512;
+            sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+            nextRenderDidError = !0;
+            value = createCapturedValue(value, sourceFiber$jscomp$0);
             do {
-              switch (root.tag) {
+              switch (returnFiber$jscomp$0.tag) {
                 case 3:
-                  root.effectTag |= 1024;
-                  value = createRootErrorUpdate(root, value, returnFiber);
-                  enqueueCapturedUpdate(root, value, returnFiber);
+                  returnFiber$jscomp$0.effectTag |= 1024;
+                  returnFiber$jscomp$0.expirationTime = returnFiber;
+                  returnFiber = createRootErrorUpdate(
+                    returnFiber$jscomp$0,
+                    value,
+                    returnFiber
+                  );
+                  enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                   break a;
                 case 2:
+                  sourceFiber$jscomp$0 = value;
+                  var instance = returnFiber$jscomp$0.stateNode;
                   if (
-                    ((returnFiber$jscomp$0 = value),
-                    (sourceFiber = root.stateNode),
-                    0 === (root.effectTag & 64) &&
-                      null !== sourceFiber &&
-                      "function" === typeof sourceFiber.componentDidCatch &&
-                      (null === legacyErrorBoundariesThatAlreadyFailed ||
-                        !legacyErrorBoundariesThatAlreadyFailed.has(
-                          sourceFiber
-                        )))
+                    0 === (returnFiber$jscomp$0.effectTag & 64) &&
+                    null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))
                   ) {
-                    root.effectTag |= 1024;
-                    value = createClassErrorUpdate(
-                      root,
+                    returnFiber$jscomp$0.effectTag |= 1024;
+                    returnFiber$jscomp$0.expirationTime = returnFiber;
+                    returnFiber = createClassErrorUpdate(
                       returnFiber$jscomp$0,
+                      sourceFiber$jscomp$0,
                       returnFiber
                     );
-                    enqueueCapturedUpdate(root, value, returnFiber);
+                    enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                     break a;
                   }
               }
-              root = root.return;
-            } while (null !== root);
+              returnFiber$jscomp$0 = returnFiber$jscomp$0.return;
+            } while (null !== returnFiber$jscomp$0);
           }
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        nextUnitOfWork = completeUnitOfWork(isYieldy);
       }
     }
     break;
   } while (1);
   isWorking = !1;
-  didFatal
-    ? (root$jscomp$0.finishedWork = null)
-    : null === nextUnitOfWork
-      ? ((didFatal = root$jscomp$0.current.alternate),
-        invariant(
-          null !== didFatal,
-          "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
-        ),
-        0 === (didFatal.effectTag & 512)
-          ? ((root$jscomp$0.pendingCommitExpirationTime = expirationTime),
-            (root$jscomp$0.finishedWork = didFatal))
-          : (!nextRenderDidError ||
-            (expirationTime !== root$jscomp$0.latestPendingTime &&
-              expirationTime !== root$jscomp$0.latestSuspendedTime)
-              ? ((didFatal = root$jscomp$0.earliestPendingTime),
-                (isYieldy = root$jscomp$0.latestPendingTime),
-                didFatal === expirationTime
-                  ? (root$jscomp$0.earliestPendingTime =
-                      isYieldy === expirationTime
-                        ? (root$jscomp$0.latestPendingTime = 0)
-                        : isYieldy)
-                  : isYieldy === expirationTime &&
-                    (root$jscomp$0.latestPendingTime = didFatal),
-                (didFatal = root$jscomp$0.latestSuspendedTime),
-                didFatal === expirationTime &&
-                  (root$jscomp$0.latestPingedTime = 0),
-                (isYieldy = root$jscomp$0.earliestSuspendedTime),
-                0 === isYieldy
-                  ? (root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime)
-                  : isYieldy > expirationTime
-                    ? (root$jscomp$0.earliestSuspendedTime = expirationTime)
-                    : didFatal < expirationTime &&
-                      (root$jscomp$0.latestSuspendedTime = expirationTime))
-              : (root$jscomp$0.didError = !0),
-            findNextPendingPriorityLevel(root$jscomp$0),
-            onSuspend(
-              root$jscomp$0,
-              expirationTime,
-              root$jscomp$0.expirationTime,
-              nextLatestTimeoutMs
-            )))
-      : (root$jscomp$0.finishedWork = null);
+  lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = ReactCurrentOwner$2.currentDispatcher = null;
+  if (didFatal) (nextRoot = null), (root.finishedWork = null);
+  else if (null !== nextUnitOfWork) root.finishedWork = null;
+  else {
+    isYieldy = root.current.alternate;
+    invariant(
+      null !== isYieldy,
+      "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
+    );
+    nextRoot = null;
+    if (nextRenderDidError) {
+      didFatal = root.latestPendingTime;
+      sourceFiber = root.latestSuspendedTime;
+      returnFiber = root.latestPingedTime;
+      if (
+        (0 !== didFatal && didFatal > expirationTime) ||
+        (0 !== sourceFiber && sourceFiber > expirationTime) ||
+        (0 !== returnFiber && returnFiber > expirationTime)
+      ) {
+        root.didError = !1;
+        isExpired = root.latestPingedTime;
+        0 !== isExpired &&
+          isExpired <= expirationTime &&
+          (root.latestPingedTime = 0);
+        isExpired = root.earliestPendingTime;
+        isYieldy = root.latestPendingTime;
+        isExpired === expirationTime
+          ? (root.earliestPendingTime =
+              isYieldy === expirationTime
+                ? (root.latestPendingTime = 0)
+                : isYieldy)
+          : isYieldy === expirationTime && (root.latestPendingTime = isExpired);
+        isExpired = root.earliestSuspendedTime;
+        isYieldy = root.latestSuspendedTime;
+        0 === isExpired
+          ? (root.earliestSuspendedTime = root.latestSuspendedTime = expirationTime)
+          : isExpired > expirationTime
+            ? (root.earliestSuspendedTime = expirationTime)
+            : isYieldy < expirationTime &&
+              (root.latestSuspendedTime = expirationTime);
+        findNextExpirationTimeToWorkOn(expirationTime, root);
+        root.expirationTime = root.expirationTime;
+        return;
+      }
+      if (!root.didError && !isExpired) {
+        root.didError = !0;
+        root.nextExpirationTimeToWorkOn = expirationTime;
+        root.expirationTime = 1;
+        return;
+      }
+    }
+    root.pendingCommitExpirationTime = expirationTime;
+    root.finishedWork = isYieldy;
+  }
 }
 function captureCommitPhaseError(fiber, error) {
   var JSCompiler_inline_result;
@@ -4579,7 +4712,7 @@ function captureCommitPhaseError(fiber, error) {
           ) {
             fiber = createCapturedValue(error, fiber);
             fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
-            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+            enqueueUpdate(JSCompiler_inline_result, fiber);
             scheduleWork(JSCompiler_inline_result, 1);
             JSCompiler_inline_result = void 0;
             break a;
@@ -4588,7 +4721,7 @@ function captureCommitPhaseError(fiber, error) {
         case 3:
           fiber = createCapturedValue(error, fiber);
           fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
-          enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+          enqueueUpdate(JSCompiler_inline_result, fiber);
           scheduleWork(JSCompiler_inline_result, 1);
           JSCompiler_inline_result = void 0;
           break a;
@@ -4602,23 +4735,25 @@ function captureCommitPhaseError(fiber, error) {
         JSCompiler_inline_result,
         1
       )),
-      enqueueUpdate(fiber, JSCompiler_inline_result, 1),
+      enqueueUpdate(fiber, JSCompiler_inline_result),
       scheduleWork(fiber, 1));
     JSCompiler_inline_result = void 0;
   }
   return JSCompiler_inline_result;
 }
 function computeExpirationForFiber(currentTime, fiber) {
-  currentTime =
-    0 !== expirationContext
-      ? expirationContext
-      : isWorking
-        ? isCommitting$1 ? 1 : nextRenderExpirationTime
-        : fiber.mode & 1
-          ? isBatchingInteractiveUpdates
+  0 !== expirationContext
+    ? (currentTime = expirationContext)
+    : isWorking
+      ? (currentTime = isCommitting$1 ? 1 : nextRenderExpirationTime)
+      : fiber.mode & 1
+        ? ((currentTime = isBatchingInteractiveUpdates
             ? 2 + 10 * ((((currentTime - 2 + 15) / 10) | 0) + 1)
-            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)
-          : 1;
+            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)),
+          null !== nextRoot &&
+            currentTime === nextRenderExpirationTime &&
+            (currentTime += 1))
+        : (currentTime = 1);
   isBatchingInteractiveUpdates &&
     (0 === lowestPendingInteractiveExpirationTime ||
       currentTime > lowestPendingInteractiveExpirationTime) &&
@@ -4626,35 +4761,51 @@ function computeExpirationForFiber(currentTime, fiber) {
   return currentTime;
 }
 function scheduleWork(fiber, expirationTime) {
-  for (; null !== fiber; ) {
+  a: {
     if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime)
       fiber.expirationTime = expirationTime;
-    null !== fiber.alternate &&
-      (0 === fiber.alternate.expirationTime ||
-        fiber.alternate.expirationTime > expirationTime) &&
-      (fiber.alternate.expirationTime = expirationTime);
-    if (null === fiber.return)
-      if (3 === fiber.tag) {
-        var root = fiber.stateNode;
-        !isWorking &&
-          0 !== nextRenderExpirationTime &&
-          expirationTime < nextRenderExpirationTime &&
-          resetStack();
-        markPendingPriorityLevel(root, expirationTime);
-        (isWorking && !isCommitting$1 && nextRoot === root) ||
-          requestWork(root, root.expirationTime);
-        nestedUpdateCount > NESTED_UPDATE_LIMIT &&
-          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."
-          );
-      } else break;
-    fiber = fiber.return;
+    var alternate = fiber.alternate;
+    null !== alternate &&
+      (0 === alternate.expirationTime ||
+        alternate.expirationTime > expirationTime) &&
+      (alternate.expirationTime = expirationTime);
+    var node = fiber.return;
+    if (null === node && 3 === fiber.tag) fiber = fiber.stateNode;
+    else {
+      for (; null !== node; ) {
+        alternate = node.alternate;
+        if (
+          0 === node.childExpirationTime ||
+          node.childExpirationTime > expirationTime
+        )
+          node.childExpirationTime = expirationTime;
+        null !== alternate &&
+          (0 === alternate.childExpirationTime ||
+            alternate.childExpirationTime > expirationTime) &&
+          (alternate.childExpirationTime = expirationTime);
+        if (null === node.return && 3 === node.tag) {
+          fiber = node.stateNode;
+          break a;
+        }
+        node = node.return;
+      }
+      fiber = null;
+    }
   }
-}
-function recalculateCurrentTime() {
-  mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
-  return (mostRecentCurrentTime = ((mostRecentCurrentTimeMs / 10) | 0) + 2);
+  null !== fiber &&
+    (!isWorking &&
+      0 !== nextRenderExpirationTime &&
+      expirationTime < nextRenderExpirationTime &&
+      resetStack(),
+    markPendingPriorityLevel(fiber, expirationTime),
+    (isWorking && !isCommitting$1 && nextRoot === fiber) ||
+      requestWork(fiber, fiber.expirationTime),
+    nestedUpdateCount > NESTED_UPDATE_LIMIT &&
+      ((nestedUpdateCount = 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."
+      )));
 }
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
@@ -4681,9 +4832,16 @@ var firstScheduledRoot = null,
   isUnbatchingUpdates = !1,
   isBatchingInteractiveUpdates = !1,
   completedBatches = null,
-  NESTED_UPDATE_LIMIT = 1e3,
+  originalStartTimeMs = now$1(),
+  currentRendererTime = ((originalStartTimeMs / 10) | 0) + 2,
+  currentSchedulerTime = currentRendererTime,
+  NESTED_UPDATE_LIMIT = 50,
   nestedUpdateCount = 0,
+  lastCommittedRootDuringThisBatch = null,
   timeHeuristicForUnitOfWork = 1;
+function recomputeCurrentRendererTime() {
+  currentRendererTime = (((now$1() - originalStartTimeMs) / 10) | 0) + 2;
+}
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (0 !== callbackExpirationTime) {
     if (expirationTime > callbackExpirationTime) return;
@@ -4698,21 +4856,16 @@ function scheduleCallbackWithExpirationTime(expirationTime) {
   scheduledCallback = performAsyncWork;
   callbackID = setTimeout(setTimeoutCallback, 1);
 }
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  0 <= timeoutMs &&
-    setTimeout(function() {
-      var latestSuspendedTime = root.latestSuspendedTime;
-      0 !== latestSuspendedTime &&
-        latestSuspendedTime <= suspendedExpirationTime &&
-        ((latestSuspendedTime = root.latestPingedTime),
-        0 === latestSuspendedTime ||
-          latestSuspendedTime < suspendedExpirationTime) &&
-        (root.latestPingedTime = suspendedExpirationTime);
-      findNextPendingPriorityLevel(root);
-      latestSuspendedTime = root.expirationTime;
-      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
-    }, timeoutMs);
-  root.expirationTime = expirationTime;
+function requestCurrentTime() {
+  if (isRendering) return currentSchedulerTime;
+  findHighestPriorityRoot();
+  if (
+    0 === nextFlushedExpirationTime ||
+    1073741823 === nextFlushedExpirationTime
+  )
+    recomputeCurrentRendererTime(),
+      (currentSchedulerTime = currentRendererTime);
+  return currentSchedulerTime;
 }
 function requestWork(root, expirationTime) {
   if (null === root.nextScheduledRoot)
@@ -4735,7 +4888,7 @@ function requestWork(root, expirationTime) {
       ? isUnbatchingUpdates &&
         ((nextFlushedRoot = root),
         (nextFlushedExpirationTime = 1),
-        performWorkOnRoot(root, 1, !1))
+        performWorkOnRoot(root, 1, !0))
       : 1 === expirationTime
         ? performWork(1, null)
         : scheduleCallbackWithExpirationTime(expirationTime));
@@ -4784,12 +4937,6 @@ function findHighestPriorityRoot() {
         root = root.nextScheduledRoot;
       }
     }
-  previousScheduledRoot = nextFlushedRoot;
-  null !== previousScheduledRoot &&
-  previousScheduledRoot === highestPriorityRoot &&
-  1 === highestPriorityWork
-    ? nestedUpdateCount++
-    : (nestedUpdateCount = 0);
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -4799,21 +4946,26 @@ function performAsyncWork(dl) {
 function performWork(minExpirationTime, dl) {
   deadline = dl;
   findHighestPriorityRoot();
-  resumeActualRenderTimerIfPaused();
+  resumeActualRenderTimerIfPaused(1 === minExpirationTime);
   if (null !== deadline)
     for (
-      ;
+      recomputeCurrentRendererTime(),
+        currentSchedulerTime = currentRendererTime;
       null !== nextFlushedRoot &&
       0 !== nextFlushedExpirationTime &&
       (0 === minExpirationTime ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime);
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime);
 
     )
-      recalculateCurrentTime(),
-        performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
-        findHighestPriorityRoot();
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      ),
+        findHighestPriorityRoot(),
+        recomputeCurrentRendererTime(),
+        (currentSchedulerTime = currentRendererTime);
   else
     for (
       ;
@@ -4823,22 +4975,22 @@ function performWork(minExpirationTime, dl) {
         minExpirationTime >= nextFlushedExpirationTime);
 
     )
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1),
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
         findHighestPriorityRoot();
   null !== deadline && ((callbackExpirationTime = 0), (callbackID = null));
   0 !== nextFlushedExpirationTime &&
     scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
   deadline = null;
   deadlineDidExpire = !1;
-  finishRendering();
-}
-function finishRendering() {
   nestedUpdateCount = 0;
-  if (null !== completedBatches) {
-    var batches = completedBatches;
-    completedBatches = null;
-    for (var i = 0; i < batches.length; i++) {
-      var batch = batches[i];
+  lastCommittedRootDuringThisBatch = null;
+  if (null !== completedBatches)
+    for (
+      minExpirationTime = completedBatches, completedBatches = null, dl = 0;
+      dl < minExpirationTime.length;
+      dl++
+    ) {
+      var batch = minExpirationTime[dl];
       try {
         batch._onComplete();
       } catch (error) {
@@ -4846,38 +4998,39 @@ function finishRendering() {
           ((hasUnhandledError = !0), (unhandledError = error));
       }
     }
-  }
   if (hasUnhandledError)
-    throw ((batches = unhandledError),
+    throw ((minExpirationTime = unhandledError),
     (unhandledError = null),
     (hasUnhandledError = !1),
-    batches);
+    minExpirationTime);
 }
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isRendering = !0;
-  isYieldy
-    ? ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot$1(root, isYieldy, expirationTime)
+  if (null === deadline || isExpired) {
+    var finishedWork = root.finishedWork;
+    null !== finishedWork
+      ? completeRoot$1(root, finishedWork, expirationTime)
+      : ((root.finishedWork = null),
+        renderRoot(root, !1, isExpired),
+        (finishedWork = root.finishedWork),
+        null !== finishedWork &&
+          completeRoot$1(root, finishedWork, expirationTime));
+  } else
+    (finishedWork = root.finishedWork),
+      null !== finishedWork
+        ? completeRoot$1(root, finishedWork, expirationTime)
         : ((root.finishedWork = null),
-          renderRoot(root, !0),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy &&
+          renderRoot(root, !0, isExpired),
+          (finishedWork = root.finishedWork),
+          null !== finishedWork &&
             (shouldYield()
-              ? ((root.finishedWork = isYieldy),
-                0 === timerPausedAt && (timerPausedAt = now$1()))
-              : completeRoot$1(root, isYieldy, expirationTime))))
-    : ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot$1(root, isYieldy, expirationTime)
-        : ((root.finishedWork = null),
-          renderRoot(root, !1),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy && completeRoot$1(root, isYieldy, expirationTime)));
+              ? ((root.finishedWork = finishedWork),
+                pauseActualRenderTimerIfRunning())
+              : completeRoot$1(root, finishedWork, expirationTime)));
   isRendering = !1;
 }
 function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
@@ -4895,6 +5048,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
     return;
   }
   root.finishedWork = null;
+  root === lastCommittedRootDuringThisBatch
+    ? nestedUpdateCount++
+    : ((lastCommittedRootDuringThisBatch = root), (nestedUpdateCount = 0));
   isCommitting$1 = isWorking = !0;
   invariant(
     root.current !== finishedWork$jscomp$0,
@@ -4907,34 +5063,39 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
   );
   root.pendingCommitExpirationTime = 0;
   firstBatch = finishedWork$jscomp$0.expirationTime;
-  recalculateCurrentTime();
+  var childExpirationTimeBeforeCommit =
+    finishedWork$jscomp$0.childExpirationTime;
+  firstBatch =
+    0 === firstBatch ||
+    (0 !== childExpirationTimeBeforeCommit &&
+      childExpirationTimeBeforeCommit < firstBatch)
+      ? childExpirationTimeBeforeCommit
+      : firstBatch;
   root.didError = !1;
-  if (0 === firstBatch)
-    (root.earliestPendingTime = 0),
+  0 === firstBatch
+    ? ((root.earliestPendingTime = 0),
       (root.latestPendingTime = 0),
       (root.earliestSuspendedTime = 0),
       (root.latestSuspendedTime = 0),
-      (root.latestPingedTime = 0);
-  else {
-    var latestPendingTime = root.latestPendingTime;
-    0 !== latestPendingTime &&
-      (latestPendingTime < firstBatch
-        ? (root.earliestPendingTime = root.latestPendingTime = 0)
-        : root.earliestPendingTime < firstBatch &&
-          (root.earliestPendingTime = root.latestPendingTime));
-    latestPendingTime = root.earliestSuspendedTime;
-    0 === latestPendingTime
-      ? markPendingPriorityLevel(root, firstBatch)
-      : firstBatch > root.latestSuspendedTime
-        ? ((root.earliestSuspendedTime = 0),
-          (root.latestSuspendedTime = 0),
-          (root.latestPingedTime = 0),
-          markPendingPriorityLevel(root, firstBatch))
-        : firstBatch < latestPendingTime &&
-          markPendingPriorityLevel(root, firstBatch);
-  }
-  findNextPendingPriorityLevel(root);
-  ReactCurrentOwner.current = null;
+      (root.latestPingedTime = 0))
+    : ((childExpirationTimeBeforeCommit = root.latestPendingTime),
+      0 !== childExpirationTimeBeforeCommit &&
+        (childExpirationTimeBeforeCommit < firstBatch
+          ? (root.earliestPendingTime = root.latestPendingTime = 0)
+          : root.earliestPendingTime < firstBatch &&
+            (root.earliestPendingTime = root.latestPendingTime)),
+      (childExpirationTimeBeforeCommit = root.earliestSuspendedTime),
+      0 === childExpirationTimeBeforeCommit
+        ? markPendingPriorityLevel(root, firstBatch)
+        : firstBatch > root.latestSuspendedTime
+          ? ((root.earliestSuspendedTime = 0),
+            (root.latestSuspendedTime = 0),
+            (root.latestPingedTime = 0),
+            markPendingPriorityLevel(root, firstBatch))
+          : firstBatch < childExpirationTimeBeforeCommit &&
+            markPendingPriorityLevel(root, firstBatch));
+  findNextExpirationTimeToWorkOn(0, root);
+  ReactCurrentOwner$2.current = null;
   1 < finishedWork$jscomp$0.effectTag
     ? null !== finishedWork$jscomp$0.lastEffect
       ? ((finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0),
@@ -4942,18 +5103,18 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
       : (firstBatch = finishedWork$jscomp$0)
     : (firstBatch = finishedWork$jscomp$0.firstEffect);
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    latestPendingTime = !1;
+    childExpirationTimeBeforeCommit = !1;
     var error = void 0;
     try {
       for (; null !== nextEffect; ) {
         if (nextEffect.effectTag & 256) {
-          var current = nextEffect.alternate,
+          var current$$1 = nextEffect.alternate,
             finishedWork = nextEffect;
           switch (finishedWork.tag) {
             case 2:
-              if (finishedWork.effectTag & 256 && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
+              if (finishedWork.effectTag & 256 && null !== current$$1) {
+                var prevProps = current$$1.memoizedProps,
+                  prevState = current$$1.memoizedState,
                   instance = finishedWork.stateNode;
                 instance.props = finishedWork.memoizedProps;
                 instance.state = finishedWork.memoizedState;
@@ -4979,9 +5140,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (latestPendingTime = !0), (error = e);
+      (childExpirationTimeBeforeCommit = !0), (error = e);
     }
-    latestPendingTime &&
+    childExpirationTimeBeforeCommit &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -4991,15 +5152,15 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
   }
   now$1();
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    current = !1;
+    current$$1 = !1;
     prevProps = void 0;
     try {
       for (; null !== nextEffect; ) {
         var effectTag = nextEffect.effectTag;
         if (effectTag & 128) {
-          var current$jscomp$0 = nextEffect.alternate;
-          if (null !== current$jscomp$0) {
-            var currentRef = current$jscomp$0.ref;
+          var current$$1$jscomp$0 = nextEffect.alternate;
+          if (null !== current$$1$jscomp$0) {
+            var currentRef = current$$1$jscomp$0.ref;
             null !== currentRef &&
               ("function" === typeof currentRef
                 ? currentRef(null)
@@ -5020,32 +5181,36 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
           case 8:
             prevState = nextEffect;
             a: for (snapshot = instance = prevState; ; ) {
-              latestPendingTime = snapshot;
-              "function" === typeof onCommitUnmount &&
-                onCommitUnmount(latestPendingTime);
-              switch (latestPendingTime.tag) {
+              childExpirationTimeBeforeCommit = snapshot;
+              "function" === typeof onCommitFiberUnmount &&
+                onCommitFiberUnmount(childExpirationTimeBeforeCommit);
+              switch (childExpirationTimeBeforeCommit.tag) {
                 case 2:
-                  safelyDetachRef(latestPendingTime);
-                  var instance$jscomp$0 = latestPendingTime.stateNode;
+                  safelyDetachRef(childExpirationTimeBeforeCommit);
+                  var instance$jscomp$0 =
+                    childExpirationTimeBeforeCommit.stateNode;
                   if (
                     "function" === typeof instance$jscomp$0.componentWillUnmount
                   )
                     try {
                       (instance$jscomp$0.props =
-                        latestPendingTime.memoizedProps),
+                        childExpirationTimeBeforeCommit.memoizedProps),
                         (instance$jscomp$0.state =
-                          latestPendingTime.memoizedState),
+                          childExpirationTimeBeforeCommit.memoizedState),
                         instance$jscomp$0.componentWillUnmount();
                     } catch (unmountError) {
-                      captureCommitPhaseError(latestPendingTime, unmountError);
+                      captureCommitPhaseError(
+                        childExpirationTimeBeforeCommit,
+                        unmountError
+                      );
                     }
                   break;
                 case 5:
-                  safelyDetachRef(latestPendingTime);
+                  safelyDetachRef(childExpirationTimeBeforeCommit);
                   break;
                 case 4:
                   FabricUIManager.createChildSet(
-                    latestPendingTime.stateNode.containerInfo
+                    childExpirationTimeBeforeCommit.stateNode.containerInfo
                   );
               }
               if (null !== snapshot.child)
@@ -5070,9 +5235,9 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (current = !0), (prevProps = e);
+      (current$$1 = !0), (prevProps = e);
     }
-    current &&
+    current$$1 &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5083,25 +5248,25 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
   root.current = finishedWork$jscomp$0;
   for (nextEffect = firstBatch; null !== nextEffect; ) {
     effectTag = !1;
-    current$jscomp$0 = void 0;
+    current$$1$jscomp$0 = void 0;
     try {
       for (currentRef = expirationTime; null !== nextEffect; ) {
         var effectTag$jscomp$0 = nextEffect.effectTag;
         if (effectTag$jscomp$0 & 36) {
-          var current$jscomp$1 = nextEffect.alternate;
+          var current$$1$jscomp$1 = nextEffect.alternate;
           instance$jscomp$0 = nextEffect;
           firstBatch = currentRef;
           switch (instance$jscomp$0.tag) {
             case 2:
               var instance$jscomp$1 = instance$jscomp$0.stateNode;
               if (instance$jscomp$0.effectTag & 4)
-                if (null === current$jscomp$1)
+                if (null === current$$1$jscomp$1)
                   (instance$jscomp$1.props = instance$jscomp$0.memoizedProps),
                     (instance$jscomp$1.state = instance$jscomp$0.memoizedState),
                     instance$jscomp$1.componentDidMount();
                 else {
-                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
-                    prevState$jscomp$0 = current$jscomp$1.memoizedState;
+                  var prevProps$jscomp$0 = current$$1$jscomp$1.memoizedProps,
+                    prevState$jscomp$0 = current$$1$jscomp$1.memoizedState;
                   instance$jscomp$1.props = instance$jscomp$0.memoizedProps;
                   instance$jscomp$1.state = instance$jscomp$0.memoizedState;
                   instance$jscomp$1.componentDidUpdate(
@@ -5124,25 +5289,25 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
             case 3:
               var _updateQueue = instance$jscomp$0.updateQueue;
               if (null !== _updateQueue) {
-                current = null;
+                current$$1 = null;
                 if (null !== instance$jscomp$0.child)
                   switch (instance$jscomp$0.child.tag) {
                     case 5:
-                      current = instance$jscomp$0.child.stateNode.canonical;
+                      current$$1 = instance$jscomp$0.child.stateNode.canonical;
                       break;
                     case 2:
-                      current = instance$jscomp$0.child.stateNode;
+                      current$$1 = instance$jscomp$0.child.stateNode;
                   }
                 commitUpdateQueue(
                   instance$jscomp$0,
                   _updateQueue,
-                  current,
+                  current$$1,
                   firstBatch
                 );
               }
               break;
             case 5:
-              null === current$jscomp$1 &&
+              null === current$$1$jscomp$1 &&
                 instance$jscomp$0.effectTag & 4 &&
                 invariant(
                   !1,
@@ -5186,32 +5351,37 @@ function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = next;
       }
     } catch (e) {
-      (effectTag = !0), (current$jscomp$0 = e);
+      (effectTag = !0), (current$$1$jscomp$0 = e);
     }
     effectTag &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
       ),
-      captureCommitPhaseError(nextEffect, current$jscomp$0),
+      captureCommitPhaseError(nextEffect, current$$1$jscomp$0),
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
-  totalElapsedPauseTime = 0;
   isWorking = isCommitting$1 = !1;
-  "function" === typeof onCommitRoot &&
-    onCommitRoot(finishedWork$jscomp$0.stateNode);
-  finishedWork$jscomp$0 = root.expirationTime;
+  "function" === typeof onCommitFiberRoot &&
+    onCommitFiberRoot(finishedWork$jscomp$0.stateNode);
+  effectTag$jscomp$0 = finishedWork$jscomp$0.expirationTime;
+  finishedWork$jscomp$0 = finishedWork$jscomp$0.childExpirationTime;
+  finishedWork$jscomp$0 =
+    0 === effectTag$jscomp$0 ||
+    (0 !== finishedWork$jscomp$0 && finishedWork$jscomp$0 < effectTag$jscomp$0)
+      ? finishedWork$jscomp$0
+      : effectTag$jscomp$0;
   0 === finishedWork$jscomp$0 &&
     (legacyErrorBoundariesThatAlreadyFailed = null);
   root.expirationTime = finishedWork$jscomp$0;
   root.finishedWork = null;
 }
 function shouldYield() {
-  return null === deadline ||
-    deadlineDidExpire ||
-    deadline.timeRemaining() > timeHeuristicForUnitOfWork
-    ? !1
-    : (deadlineDidExpire = !0);
+  return deadlineDidExpire
+    ? !0
+    : null === deadline || deadline.timeRemaining() > timeHeuristicForUnitOfWork
+      ? !1
+      : (deadlineDidExpire = !0);
 }
 function onUncaughtError(error) {
   invariant(
@@ -5228,7 +5398,7 @@ function updateContainerAtExpirationTime(
   expirationTime,
   callback
 ) {
-  var current = container.current;
+  var current$$1 = container.current;
   if (parentComponent) {
     parentComponent = parentComponent._reactInternalFiber;
     var parentContext;
@@ -5254,7 +5424,7 @@ function updateContainerAtExpirationTime(
     parentComponent = isContextProvider(parentComponent)
       ? processChildContext(parentComponent, parentContext)
       : parentContext;
-  } else parentComponent = emptyObject;
+  } else parentComponent = emptyContextObject;
   null === container.context
     ? (container.context = parentComponent)
     : (container.pendingContext = parentComponent);
@@ -5263,8 +5433,8 @@ function updateContainerAtExpirationTime(
   callback.payload = { element: element };
   container = void 0 === container ? null : container;
   null !== container && (callback.callback = container);
-  enqueueUpdate(current, callback, expirationTime);
-  scheduleWork(current, expirationTime);
+  enqueueUpdate(current$$1, callback);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 function findHostInstance$1(component) {
@@ -5281,14 +5451,14 @@ function findHostInstance$1(component) {
   return null === component ? null : component.stateNode;
 }
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    currentTime = recalculateCurrentTime();
-  current = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current,
+    currentTime = requestCurrentTime();
+  current$$1 = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
     parentComponent,
-    current,
+    current$$1,
     callback
   );
 }
@@ -5331,14 +5501,13 @@ var ReactFabricRenderer = {
     );
     nextFlushedRoot = root;
     nextFlushedExpirationTime = expirationTime;
-    performWorkOnRoot(root, expirationTime, !1);
+    performWorkOnRoot(root, expirationTime, !0);
     performWork(1, null);
-    finishRendering();
+    pauseActualRenderTimerIfRunning();
   },
   requestWork: requestWork,
   computeUniqueAsyncExpiration: function() {
-    var result =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var result = 2 + 25 * ((((requestCurrentTime() - 2 + 500) / 25) | 0) + 1);
     result <= lastUniqueAsyncExpiration &&
       (result = lastUniqueAsyncExpiration + 1);
     return (lastUniqueAsyncExpiration = result);
@@ -5366,9 +5535,9 @@ var ReactFabricRenderer = {
     return fn(a);
   },
   deferredUpdates: function(fn) {
-    var previousExpirationContext = expirationContext;
-    expirationContext =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var currentTime = requestCurrentTime(),
+      previousExpirationContext = expirationContext;
+    expirationContext = 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1);
     try {
       return fn();
     } finally {
@@ -5540,7 +5709,7 @@ var roots = new Map(),
               maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
             nativeProps = diffProperties(
               null,
-              emptyObject$1,
+              emptyObject,
               nativeProps,
               viewConfig.validAttributes
             );
@@ -5611,7 +5780,7 @@ var roots = new Map(),
               var viewConfig = maybeInstance.viewConfig;
               nativeProps = diffProperties(
                 null,
-                emptyObject$1,
+                emptyObject,
                 nativeProps,
                 viewConfig.validAttributes
               );
diff --git a/Libraries/Renderer/oss/ReactNativeRenderer-dev.js b/Libraries/Renderer/oss/ReactNativeRenderer-dev.js
index c18f1f137..05f219810 100644
--- a/Libraries/Renderer/oss/ReactNativeRenderer-dev.js
+++ b/Libraries/Renderer/oss/ReactNativeRenderer-dev.js
@@ -17,13 +17,10 @@ if (__DEV__) {
 "use strict";
 
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant");
-var warning = require("fbjs/lib/warning");
 var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry");
 var UIManager = require("UIManager");
 var RCTEventEmitter = require("RCTEventEmitter");
 var React = require("react");
-var emptyObject = require("fbjs/lib/emptyObject");
 var deepFreezeAndThrowOnMutationInDev = require("deepFreezeAndThrowOnMutationInDev");
 var deepDiffer = require("deepDiffer");
 var flattenStyle = require("flattenStyle");
@@ -31,6 +28,53 @@ var TextInputState = require("TextInputState");
 var checkPropTypes = require("prop-types/checkPropTypes");
 var ExceptionsManager = require("ExceptionsManager");
 
+/**
+ * Use invariant() to assert state which your program assumes to be true.
+ *
+ * Provide sprintf-style format (only %s is supported) and arguments
+ * to provide information about what broke and what you were
+ * expecting.
+ *
+ * The invariant message will be stripped in production, but the invariant
+ * will remain to ensure logic does not differ in production.
+ */
+
+var validateFormat = function() {};
+
+{
+  validateFormat = function(format) {
+    if (format === undefined) {
+      throw new Error("invariant requires an error message argument");
+    }
+  };
+}
+
+function invariant(condition, format, a, b, c, d, e, f) {
+  validateFormat(format);
+
+  if (!condition) {
+    var error = void 0;
+    if (format === undefined) {
+      error = new Error(
+        "Minified exception occurred; use the non-minified dev environment " +
+          "for the full error message and additional helpful warnings."
+      );
+    } else {
+      var args = [a, b, c, d, e, f];
+      var argIndex = 0;
+      error = new Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      error.name = "Invariant Violation";
+    }
+
+    error.framesToPop = 1; // we don't care about invariant's own frame
+    throw error;
+  }
+}
+
 var invokeGuardedCallback = function(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = false;
   this._caughtError = null;
@@ -499,6 +543,61 @@ function injectEventPluginsByName(injectedNamesToPlugins) {
   }
 }
 
+/**
+ * Similar to invariant but only logs a warning if the condition is not met.
+ * This can be used to log issues in development environments in critical
+ * paths. Removing the logging code for production environments will keep the
+ * same logic and follow the same code paths.
+ */
+
+var warningWithoutStack = function() {};
+
+{
+  warningWithoutStack = function(condition, format) {
+    for (
+      var _len = arguments.length,
+        args = Array(_len > 2 ? _len - 2 : 0),
+        _key = 2;
+      _key < _len;
+      _key++
+    ) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    if (format === undefined) {
+      throw new Error(
+        "`warningWithoutStack(condition, format, ...args)` requires a warning " +
+          "message argument"
+      );
+    }
+    if (condition) {
+      return;
+    }
+    if (typeof console !== "undefined") {
+      var _console;
+
+      (_console = console).error.apply(
+        _console,
+        ["Warning: " + format].concat(args)
+      );
+    }
+    try {
+      // --- Welcome to debugging React ---
+      // This error was thrown as a convenience so that you can use this stack
+      // to find the callsite that caused this warning to fire.
+      var argIndex = 0;
+      var message =
+        "Warning: " +
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        });
+      throw new Error(message);
+    } catch (x) {}
+  };
+}
+
+var warningWithoutStack$1 = warningWithoutStack;
+
 var getFiberCurrentPropsFromNode = null;
 var getInstanceFromNode = null;
 var getNodeFromInstance = null;
@@ -511,7 +610,7 @@ var injection$1 = {
 
     {
       !(getNodeFromInstance && getInstanceFromNode)
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "EventPluginUtils.injection.injectComponentTree(...): Injected " +
               "module is missing getNodeFromInstance or getInstanceFromNode."
@@ -530,15 +629,19 @@ var validateEventDispatches = void 0;
     var listenersIsArr = Array.isArray(dispatchListeners);
     var listenersLen = listenersIsArr
       ? dispatchListeners.length
-      : dispatchListeners ? 1 : 0;
+      : dispatchListeners
+        ? 1
+        : 0;
 
     var instancesIsArr = Array.isArray(dispatchInstances);
     var instancesLen = instancesIsArr
       ? dispatchInstances.length
-      : dispatchInstances ? 1 : 0;
+      : dispatchInstances
+        ? 1
+        : 0;
 
     !(instancesIsArr === listenersIsArr && instancesLen === listenersLen)
-      ? warning(false, "EventPluginUtils: Invalid `event`.")
+      ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.")
       : void 0;
   };
 }
@@ -951,7 +1054,7 @@ var ContextConsumer = 12;
 var ContextProvider = 13;
 var ForwardRef = 14;
 var Profiler = 15;
-var TimeoutComponent = 16;
+var PlaceholderComponent = 16;
 
 function getParent(inst) {
   do {
@@ -1080,7 +1183,9 @@ function listenerAtPhase(inst, event, propagationPhase) {
  */
 function accumulateDirectionalDispatches(inst, phase, event) {
   {
-    !inst ? warning(false, "Dispatching inst must not be null") : void 0;
+    !inst
+      ? warningWithoutStack$1(false, "Dispatching inst must not be null")
+      : void 0;
   }
   var listener = listenerAtPhase(inst, event, phase);
   if (listener) {
@@ -1160,19 +1265,8 @@ function accumulateDirectDispatches(events) {
 
 /* eslint valid-typeof: 0 */
 
-var didWarnForAddedNewProperty = false;
 var EVENT_POOL_SIZE = 10;
 
-var shouldBeReleasedProperties = [
-  "dispatchConfig",
-  "_targetInst",
-  "nativeEvent",
-  "isDefaultPrevented",
-  "isPropagationStopped",
-  "_dispatchListeners",
-  "_dispatchInstances"
-];
-
 /**
  * @interface Event
  * @see http://www.w3.org/TR/DOM-Level-3-Events/
@@ -1231,6 +1325,8 @@ function SyntheticEvent(
     delete this.nativeEvent;
     delete this.preventDefault;
     delete this.stopPropagation;
+    delete this.isDefaultPrevented;
+    delete this.isPropagationStopped;
   }
 
   this.dispatchConfig = dispatchConfig;
@@ -1336,15 +1432,35 @@ Object.assign(SyntheticEvent.prototype, {
         );
       }
     }
-    for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
-      this[shouldBeReleasedProperties[i]] = null;
-    }
+    this.dispatchConfig = null;
+    this._targetInst = null;
+    this.nativeEvent = null;
+    this.isDefaultPrevented = functionThatReturnsFalse;
+    this.isPropagationStopped = functionThatReturnsFalse;
+    this._dispatchListeners = null;
+    this._dispatchInstances = null;
     {
       Object.defineProperty(
         this,
         "nativeEvent",
         getPooledWarningPropertyDefinition("nativeEvent", null)
       );
+      Object.defineProperty(
+        this,
+        "isDefaultPrevented",
+        getPooledWarningPropertyDefinition(
+          "isDefaultPrevented",
+          functionThatReturnsFalse
+        )
+      );
+      Object.defineProperty(
+        this,
+        "isPropagationStopped",
+        getPooledWarningPropertyDefinition(
+          "isPropagationStopped",
+          functionThatReturnsFalse
+        )
+      );
       Object.defineProperty(
         this,
         "preventDefault",
@@ -1385,51 +1501,6 @@ SyntheticEvent.extend = function(Interface) {
   return Class;
 };
 
-/** Proxying after everything set on SyntheticEvent
- * to resolve Proxy issue on some WebKit browsers
- * in which some Event properties are set to undefined (GH#10010)
- */
-{
-  var isProxySupported =
-    typeof Proxy === "function" &&
-    // https://github.com/facebook/react/issues/12011
-    !Object.isSealed(new Proxy({}, {}));
-
-  if (isProxySupported) {
-    /*eslint-disable no-func-assign */
-    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) {
-            if (
-              prop !== "isPersistent" &&
-              !target.constructor.Interface.hasOwnProperty(prop) &&
-              shouldBeReleasedProperties.indexOf(prop) === -1
-            ) {
-              !(didWarnForAddedNewProperty || target.isPersistent())
-                ? warning(
-                    false,
-                    "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."
-                  )
-                : void 0;
-              didWarnForAddedNewProperty = true;
-            }
-            target[prop] = value;
-            return true;
-          }
-        });
-      }
-    });
-    /*eslint-enable no-func-assign */
-  }
-}
-
 addEventPoolingTo(SyntheticEvent);
 
 /**
@@ -1465,7 +1536,7 @@ function getPooledWarningPropertyDefinition(propName, getVal) {
   function warn(action, result) {
     var warningCondition = false;
     !warningCondition
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "This synthetic event is reused for performance reasons. If you're seeing this, " +
             "you're %s `%s` on a released/nullified synthetic event. %s. " +
@@ -1504,7 +1575,7 @@ function releasePooledEvent(event) {
   var EventConstructor = this;
   invariant(
     event instanceof EventConstructor,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
@@ -1518,14 +1589,12 @@ function addEventPoolingTo(EventConstructor) {
   EventConstructor.release = releasePooledEvent;
 }
 
-var SyntheticEvent$1 = SyntheticEvent;
-
 /**
  * `touchHistory` isn't actually on the native event, but putting it in the
  * interface will ensure that it is cleaned up when pooled/destroyed. The
  * `ResponderEventPlugin` will populate it appropriately.
  */
-var ResponderSyntheticEvent = SyntheticEvent$1.extend({
+var ResponderSyntheticEvent = SyntheticEvent.extend({
   touchHistory: function(nativeEvent) {
     return null; // Actually doesn't even look at the native event.
   }
@@ -1617,7 +1686,7 @@ function getTouchIdentifier(_ref) {
   invariant(identifier != null, "Touch object is missing identifier.");
   {
     !(identifier <= MAX_TOUCH_BANK)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Touch identifier %s is greater than maximum supported %s which causes " +
             "performance issues backfilling array locations for all of the indices.",
@@ -1724,7 +1793,7 @@ var ResponderTouchHistoryStore = {
         {
           var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
           !(activeRecord != null && activeRecord.touchActive)
-            ? warning(false, "Cannot find single active touch.")
+            ? warningWithoutStack$1(false, "Cannot find single active touch.")
             : void 0;
         }
       }
@@ -2279,7 +2348,9 @@ var ResponderEventPlugin = {
       ? eventTypes$1.responderStart
       : isResponderTouchMove
         ? eventTypes$1.responderMove
-        : isResponderTouchEnd ? eventTypes$1.responderEnd : null;
+        : isResponderTouchEnd
+          ? eventTypes$1.responderEnd
+          : null;
 
     if (incrementalTouch) {
       var gesture = ResponderSyntheticEvent.getPooled(
@@ -2302,7 +2373,9 @@ var ResponderEventPlugin = {
       noResponderTouches(nativeEvent);
     var finalTouch = isResponderTerminate
       ? eventTypes$1.responderTerminate
-      : isResponderRelease ? eventTypes$1.responderRelease : null;
+      : isResponderRelease
+        ? eventTypes$1.responderRelease
+        : null;
     if (finalTouch) {
       var finalEvent = ResponderSyntheticEvent.getPooled(
         finalTouch,
@@ -2362,7 +2435,7 @@ var ReactNativeBridgeEventPlugin = {
       'Unsupported top level event type "%s" dispatched',
       topLevelType
     );
-    var event = SyntheticEvent$1.getPooled(
+    var event = SyntheticEvent.getPooled(
       bubbleDispatchConfig || directDispatchConfig,
       targetInst,
       nativeEvent,
@@ -2682,7 +2755,7 @@ function receiveTouches(eventTopLevelType, touches, changedIndices) {
     if (target !== null && target !== undefined) {
       if (target < 1) {
         {
-          warning(
+          warningWithoutStack$1(
             false,
             "A view is reporting that a touch occurred on tag zero."
           );
@@ -2752,10 +2825,8 @@ function set(key, value) {
   key._reactInternalFiber = value;
 }
 
-var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
-
-var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;
-var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;
+var ReactSharedInternals =
+  React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
 
 // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
 // nor polyfill, then a plain number is used for performance.
@@ -2774,7 +2845,9 @@ var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 0xeacf;
 var REACT_FORWARD_REF_TYPE = hasSymbol
   ? Symbol.for("react.forward_ref")
   : 0xead0;
-var REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 0xead1;
+var REACT_PLACEHOLDER_TYPE = hasSymbol
+  ? Symbol.for("react.placeholder")
+  : 0xead1;
 
 var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
 var FAUX_ITERATOR_SYMBOL = "@@iterator";
@@ -2792,11 +2865,22 @@ function getIteratorFn(maybeIterable) {
   return null;
 }
 
-function getComponentName(fiber) {
-  var type = fiber.type;
-
+function getComponentName(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+  {
+    if (typeof type.tag === "number") {
+      warningWithoutStack$1(
+        false,
+        "Received an unexpected object in getComponentName(). " +
+          "This is likely a bug in React. Please file an issue."
+      );
+    }
+  }
   if (typeof type === "function") {
-    return type.displayName || type.name;
+    return type.displayName || type.name || null;
   }
   if (typeof type === "string") {
     return type;
@@ -2804,25 +2888,26 @@ function getComponentName(fiber) {
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if (typeof type === "object" && type !== null) {
+  if (typeof type === "object") {
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
-        var functionName = type.render.displayName || type.render.name || "";
+        var renderFn = type.render;
+        var functionName = renderFn.displayName || renderFn.name || "";
         return functionName !== ""
           ? "ForwardRef(" + functionName + ")"
           : "ForwardRef";
@@ -2846,12 +2931,17 @@ var DidCapture = /*            */ 64;
 var Ref = /*                   */ 128;
 var Snapshot = /*              */ 256;
 
+// Update & Callback & Ref & Snapshot
+var LifecycleEffectMask = /*   */ 420;
+
 // Union of all host effects
 var HostEffectMask = /*        */ 511;
 
 var Incomplete = /*            */ 512;
 var ShouldCapture = /*         */ 1024;
 
+var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
+
 var MOUNTING = 1;
 var MOUNTED = 2;
 var UNMOUNTED = 3;
@@ -2891,19 +2981,19 @@ function isFiberMounted(fiber) {
 
 function isMounted(component) {
   {
-    var owner = ReactCurrentOwner.current;
+    var owner = ReactCurrentOwner$1.current;
     if (owner !== null && owner.tag === ClassComponent) {
       var ownerFiber = owner;
       var instance = ownerFiber.stateNode;
       !instance._warnedAboutRefsInRender
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s is accessing isMounted inside its render() function. " +
               "render() should be a pure function of props and state. It should " +
               "never access something that requires stale data from the previous " +
               "render, such as refs. Move this logic to componentDidMount and " +
               "componentDidUpdate instead.",
-            getComponentName(ownerFiber) || "A component"
+            getComponentName(ownerFiber.type) || "A component"
           )
         : void 0;
       instance._warnedAboutRefsInRender = true;
@@ -3117,7 +3207,7 @@ function findCurrentHostFiberWithNoPortals(parent) {
 }
 
 // Modules provided by RN:
-var emptyObject$1 = {};
+var emptyObject = {};
 
 /**
  * Create a payload that contains all the updates between two sets of props.
@@ -3521,7 +3611,7 @@ function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
  */
 function addProperties(updatePayload, props, validAttributes) {
   // TODO: Fast path
-  return diffProperties(updatePayload, emptyObject$1, props, validAttributes);
+  return diffProperties(updatePayload, emptyObject, props, validAttributes);
 }
 
 /**
@@ -3530,12 +3620,7 @@ function addProperties(updatePayload, props, validAttributes) {
  */
 function clearProperties(updatePayload, prevProps, validAttributes) {
   // TODO: Fast path
-  return diffProperties(
-    updatePayload,
-    prevProps,
-    emptyObject$1,
-    validAttributes
-  );
+  return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
 }
 
 function create(props, validAttributes) {
@@ -3803,6 +3888,11 @@ var didNotFindHydratableTextInstance = shim$1;
 // Modules provided by RN:
 // Unused
 
+var UPDATE_SIGNAL = {};
+{
+  Object.freeze(UPDATE_SIGNAL);
+}
+
 // Counter for uniquely identifying views.
 // % 10 === 1 means it is a rootTag.
 // % 2 === 0 means it is a Fabric tag.
@@ -3962,7 +4052,7 @@ function prepareUpdate(
   rootContainerInstance,
   hostContext
 ) {
-  return emptyObject;
+  return UPDATE_SIGNAL;
 }
 
 function resetAfterCommit(containerInfo) {
@@ -3974,6 +4064,10 @@ var isPrimaryRenderer = true;
 var scheduleDeferredCallback = scheduleDeferredCallback$1;
 var cancelDeferredCallback = cancelDeferredCallback$1;
 
+var scheduleTimeout = setTimeout;
+var cancelTimeout = clearTimeout;
+var noTimeout = -1;
+
 function shouldDeprioritizeSubtree(type, props) {
   return false;
 }
@@ -4156,22 +4250,27 @@ var describeComponentFrame = function(name, source, ownerName) {
         ":" +
         source.lineNumber +
         ")"
-      : ownerName ? " (created by " + ownerName + ")" : "")
+      : ownerName
+        ? " (created by " + ownerName + ")"
+        : "")
   );
 };
 
+var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+
 function describeFiber(fiber) {
   switch (fiber.tag) {
     case IndeterminateComponent:
     case FunctionalComponent:
     case ClassComponent:
     case HostComponent:
+    case Mode:
       var owner = fiber._debugOwner;
       var source = fiber._debugSource;
-      var name = getComponentName(fiber);
+      var name = getComponentName(fiber.type);
       var ownerName = null;
       if (owner) {
-        ownerName = getComponentName(owner);
+        ownerName = getComponentName(owner.type);
       }
       return describeComponentFrame(name, source, ownerName);
     default:
@@ -4179,73 +4278,66 @@ function describeFiber(fiber) {
   }
 }
 
-// This function can only be called with a work-in-progress fiber and
-// only during begin or complete phase. Do not call it under any other
-// circumstances.
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   var node = workInProgress;
   do {
     info += describeFiber(node);
-    // Otherwise this return pointer might point to the wrong tree:
     node = node.return;
   } while (node);
   return info;
 }
 
-function getCurrentFiberOwnerName() {
+var current = null;
+var phase = null;
+
+function getCurrentFiberOwnerNameInDevOrNull() {
   {
-    var fiber = ReactDebugCurrentFiber.current;
-    if (fiber === null) {
+    if (current === null) {
       return null;
     }
-    var owner = fiber._debugOwner;
+    var owner = current._debugOwner;
     if (owner !== null && typeof owner !== "undefined") {
-      return getComponentName(owner);
+      return getComponentName(owner.type);
     }
   }
   return null;
 }
 
-function getCurrentFiberStackAddendum() {
+function getCurrentFiberStackInDev() {
   {
-    var fiber = ReactDebugCurrentFiber.current;
-    if (fiber === null) {
-      return null;
+    if (current === null) {
+      return "";
     }
     // Safe because if current fiber exists, we are reconciling,
     // and it is guaranteed to be the work-in-progress version.
-    return getStackAddendumByWorkInProgressFiber(fiber);
+    return getStackByFiberInDevAndProd(current);
   }
-  return null;
+  return "";
 }
 
 function resetCurrentFiber() {
-  ReactDebugCurrentFrame.getCurrentStack = null;
-  ReactDebugCurrentFiber.current = null;
-  ReactDebugCurrentFiber.phase = null;
+  {
+    ReactDebugCurrentFrame.getCurrentStack = null;
+    current = null;
+    phase = null;
+  }
 }
 
 function setCurrentFiber(fiber) {
-  ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum;
-  ReactDebugCurrentFiber.current = fiber;
-  ReactDebugCurrentFiber.phase = null;
+  {
+    ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
+    current = fiber;
+    phase = null;
+  }
 }
 
-function setCurrentPhase(phase) {
-  ReactDebugCurrentFiber.phase = phase;
+function setCurrentPhase(lifeCyclePhase) {
+  {
+    phase = lifeCyclePhase;
+  }
 }
 
-var ReactDebugCurrentFiber = {
-  current: null,
-  phase: null,
-  resetCurrentFiber: resetCurrentFiber,
-  setCurrentFiber: setCurrentFiber,
-  setCurrentPhase: setCurrentPhase,
-  getCurrentFiberOwnerName: getCurrentFiberOwnerName,
-  getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
-};
-
 var debugRenderPhaseSideEffects = false;
 var debugRenderPhaseSideEffectsForStrictMode = false;
 var enableGetDerivedStateFromCatch = false;
@@ -4295,9 +4387,9 @@ var formatMarkName = function(markName) {
   return reactEmoji + " " + markName;
 };
 
-var formatLabel = function(label, warning$$1) {
-  var prefix = warning$$1 ? warningEmoji + " " : reactEmoji + " ";
-  var suffix = warning$$1 ? " Warning: " + warning$$1 : "";
+var formatLabel = function(label, warning) {
+  var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
+  var suffix = warning ? " Warning: " + warning : "";
   return "" + prefix + label + suffix;
 };
 
@@ -4309,9 +4401,9 @@ var clearMark = function(markName) {
   performance.clearMarks(formatMarkName(markName));
 };
 
-var endMark = function(label, markName, warning$$1) {
+var endMark = function(label, markName, warning) {
   var formattedMarkName = formatMarkName(markName);
-  var formattedLabel = formatLabel(label, warning$$1);
+  var formattedLabel = formatLabel(label, warning);
   try {
     performance.measure(formattedLabel, formattedMarkName);
   } catch (err) {}
@@ -4339,7 +4431,7 @@ var getFiberLabel = function(componentName, isMounted, phase) {
 };
 
 var beginFiberMark = function(fiber, phase) {
-  var componentName = getComponentName(fiber) || "Unknown";
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
@@ -4358,7 +4450,7 @@ var beginFiberMark = function(fiber, phase) {
 };
 
 var clearFiberMark = function(fiber, phase) {
-  var componentName = getComponentName(fiber) || "Unknown";
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
@@ -4366,13 +4458,13 @@ var clearFiberMark = function(fiber, phase) {
   clearMark(markName);
 };
 
-var endFiberMark = function(fiber, phase, warning$$1) {
-  var componentName = getComponentName(fiber) || "Unknown";
+var endFiberMark = function(fiber, phase, warning) {
+  var componentName = getComponentName(fiber.type) || "Unknown";
   var debugID = fiber._debugID;
   var isMounted = fiber.alternate !== null;
   var label = getFiberLabel(componentName, isMounted, phase);
   var markName = getFiberMarkName(label, debugID);
-  endMark(label, markName, warning$$1);
+  endMark(label, markName, warning);
 };
 
 var shouldIgnoreFiber = function(fiber) {
@@ -4464,13 +4556,13 @@ function stopRequestCallbackTimer(didExpire, expirationTime) {
   if (enableUserTimingAPI) {
     if (supportsUserTiming) {
       isWaitingForCallback = false;
-      var warning$$1 = didExpire ? "React was blocked by main thread" : null;
+      var warning = didExpire ? "React was blocked by main thread" : null;
       endMark(
         "(Waiting for async callback... will force flush in " +
           expirationTime +
           " ms)",
         "(Waiting for async callback...)",
-        warning$$1
+        warning
       );
     }
   }
@@ -4528,8 +4620,8 @@ function stopFailedWorkTimer(fiber) {
       return;
     }
     fiber._debugIsCurrentlyTiming = false;
-    var warning$$1 = "An error was thrown inside this error boundary";
-    endFiberMark(fiber, null, warning$$1);
+    var warning = "An error was thrown inside this error boundary";
+    endFiberMark(fiber, null, warning);
   }
 }
 
@@ -4553,10 +4645,10 @@ function stopPhaseTimer() {
       return;
     }
     if (currentPhase !== null && currentPhaseFiber !== null) {
-      var warning$$1 = hasScheduledUpdateInCurrentPhase
+      var warning = hasScheduledUpdateInCurrentPhase
         ? "Scheduled a cascading update"
         : null;
-      endFiberMark(currentPhaseFiber, currentPhase, warning$$1);
+      endFiberMark(currentPhaseFiber, currentPhase, warning);
     }
     currentPhase = null;
     currentPhaseFiber = null;
@@ -4583,17 +4675,17 @@ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
     if (!supportsUserTiming) {
       return;
     }
-    var warning$$1 = null;
+    var warning = null;
     if (interruptedBy !== null) {
       if (interruptedBy.tag === HostRoot) {
-        warning$$1 = "A top-level update interrupted the previous render";
+        warning = "A top-level update interrupted the previous render";
       } else {
-        var componentName = getComponentName(interruptedBy) || "Unknown";
-        warning$$1 =
+        var componentName = getComponentName(interruptedBy.type) || "Unknown";
+        warning =
           "An update to " + componentName + " interrupted the previous render";
       }
     } else if (commitCountInCurrentWorkLoop > 1) {
-      warning$$1 = "There were cascading updates";
+      warning = "There were cascading updates";
     }
     commitCountInCurrentWorkLoop = 0;
     var label = didCompleteRoot
@@ -4601,7 +4693,7 @@ function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
       : "(React Tree Reconciliation: Yielded)";
     // Pause any measurements until the next loop.
     pauseTimers();
-    endMark(label, "(React Tree Reconciliation)", warning$$1);
+    endMark(label, "(React Tree Reconciliation)", warning);
   }
 }
 
@@ -4623,18 +4715,18 @@ function stopCommitTimer() {
       return;
     }
 
-    var warning$$1 = null;
+    var warning = null;
     if (hasScheduledUpdateInCurrentCommit) {
-      warning$$1 = "Lifecycle hook scheduled a cascading update";
+      warning = "Lifecycle hook scheduled a cascading update";
     } else if (commitCountInCurrentWorkLoop > 0) {
-      warning$$1 = "Caused by a cascading update in earlier commit";
+      warning = "Caused by a cascading update in earlier commit";
     }
     hasScheduledUpdateInCurrentCommit = false;
     commitCountInCurrentWorkLoop++;
     isCommitting = false;
     labelsInCurrentCommit.clear();
 
-    endMark("(Committing Changes)", "(Committing Changes)", warning$$1);
+    endMark("(Committing Changes)", "(Committing Changes)", warning);
   }
 }
 
@@ -4732,14 +4824,14 @@ function createCursor(defaultValue) {
 function pop(cursor, fiber) {
   if (index < 0) {
     {
-      warning(false, "Unexpected pop.");
+      warningWithoutStack$1(false, "Unexpected pop.");
     }
     return;
   }
 
   {
     if (fiber !== fiberStack[index]) {
-      warning(false, "Unexpected Fiber popped.");
+      warningWithoutStack$1(false, "Unexpected Fiber popped.");
     }
   }
 
@@ -4769,7 +4861,7 @@ function push(cursor, value, fiber) {
 function checkThatStackIsEmpty() {
   {
     if (index !== -1) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected an empty stack. Something was not reset properly."
       );
@@ -4791,14 +4883,19 @@ var warnedAboutMissingGetChildContext = void 0;
   warnedAboutMissingGetChildContext = {};
 }
 
+var emptyContextObject = {};
+{
+  Object.freeze(emptyContextObject);
+}
+
 // A cursor to the current merged context object on the stack.
-var contextStackCursor = createCursor(emptyObject);
+var contextStackCursor = createCursor(emptyContextObject);
 // A cursor to a boolean indicating whether the context has changed.
 var didPerformWorkStackCursor = createCursor(false);
 // Keep track of the previous context object that was on the stack.
 // We use this to get access to the parent context after we have already
 // pushed the next context provider, and now need to merge their contexts.
-var previousContext = emptyObject;
+var previousContext = emptyContextObject;
 
 function getUnmaskedContext(workInProgress) {
   var hasOwnContext = isContextProvider(workInProgress);
@@ -4822,7 +4919,7 @@ function getMaskedContext(workInProgress, unmaskedContext) {
   var type = workInProgress.type;
   var contextTypes = type.contextTypes;
   if (!contextTypes) {
-    return emptyObject;
+    return emptyContextObject;
   }
 
   // Avoid recreating masked context unless unmasked context has changed.
@@ -4842,13 +4939,13 @@ function getMaskedContext(workInProgress, unmaskedContext) {
   }
 
   {
-    var name = getComponentName(workInProgress) || "Unknown";
+    var name = getComponentName(type) || "Unknown";
     checkPropTypes(
       contextTypes,
       context,
       "context",
       name,
-      ReactDebugCurrentFiber.getCurrentFiberStackAddendum
+      getCurrentFiberStackInDev
     );
   }
 
@@ -4889,7 +4986,7 @@ function popTopLevelContextObject(fiber) {
 
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "Unexpected context found on stack. " +
       "This error is likely caused by a bug in React. Please file an issue."
   );
@@ -4900,17 +4997,18 @@ function pushTopLevelContextObject(fiber, context, didChange) {
 
 function processChildContext(fiber, parentContext) {
   var instance = fiber.stateNode;
-  var childContextTypes = fiber.type.childContextTypes;
+  var type = fiber.type;
+  var childContextTypes = type.childContextTypes;
 
   // TODO (bvaughn) Replace this behavior with an invariant() in the future.
   // It has only been added in Fiber to match the (unintentional) behavior in Stack.
   if (typeof instance.getChildContext !== "function") {
     {
-      var componentName = getComponentName(fiber) || "Unknown";
+      var componentName = getComponentName(type) || "Unknown";
 
       if (!warnedAboutMissingGetChildContext[componentName]) {
         warnedAboutMissingGetChildContext[componentName] = true;
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.childContextTypes is specified but there is no getChildContext() method " +
             "on the instance. You can either define getChildContext() on %s or remove " +
@@ -4925,24 +5023,24 @@ function processChildContext(fiber, parentContext) {
 
   var childContext = void 0;
   {
-    ReactDebugCurrentFiber.setCurrentPhase("getChildContext");
+    setCurrentPhase("getChildContext");
   }
   startPhaseTimer(fiber, "getChildContext");
   childContext = instance.getChildContext();
   stopPhaseTimer();
   {
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
   for (var contextKey in childContext) {
     invariant(
       contextKey in childContextTypes,
       '%s.getChildContext(): key "%s" is not defined in childContextTypes.',
-      getComponentName(fiber) || "Unknown",
+      getComponentName(type) || "Unknown",
       contextKey
     );
   }
   {
-    var name = getComponentName(fiber) || "Unknown";
+    var name = getComponentName(type) || "Unknown";
     checkPropTypes(
       childContextTypes,
       childContext,
@@ -4953,7 +5051,7 @@ function processChildContext(fiber, parentContext) {
       // context from the parent component instance. The stack will be missing
       // because it's outside of the reconciliation, and so the pointer has not
       // been set. This is rare and doesn't matter. We'll also remove that API.
-      ReactDebugCurrentFiber.getCurrentFiberStackAddendum
+      getCurrentFiberStackInDev
     );
   }
 
@@ -4971,7 +5069,7 @@ function pushContextProvider(workInProgress) {
   // and replace it on the stack later when invalidating the context.
   var memoizedMergedChildContext =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
 
   // Remember the parent context so we can merge with it later.
   // Inherit the parent's did-perform-work value to avoid inadvertently blocking updates.
@@ -5039,14 +5137,96 @@ function findCurrentUnmaskedContext(fiber) {
   return node.stateNode.context;
 }
 
+var onCommitFiberRoot = null;
+var onCommitFiberUnmount = null;
+var hasLoggedError = false;
+
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {
+      if (true && !hasLoggedError) {
+        hasLoggedError = true;
+        warningWithoutStack$1(
+          false,
+          "React DevTools encountered an error: %s",
+          err
+        );
+      }
+    }
+  };
+}
+
+var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";
+
+function injectInternals(internals) {
+  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
+    // No DevTools
+    return false;
+  }
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled) {
+    // This isn't a real property on the hook, but it can be set to opt out
+    // of DevTools integration and associated warnings and logs.
+    // https://github.com/facebook/react/issues/3877
+    return true;
+  }
+  if (!hook.supportsFiber) {
+    {
+      warningWithoutStack$1(
+        false,
+        "The installed version of React DevTools is too old and will not work " +
+          "with the current version of React. Please update React DevTools. " +
+          "https://fb.me/react-devtools"
+      );
+    }
+    // DevTools exists, even though it doesn't support Fiber.
+    return true;
+  }
+  try {
+    var rendererID = hook.inject(internals);
+    // We have successfully injected, so now it is safe to set up hooks.
+    onCommitFiberRoot = catchErrors(function(root) {
+      return hook.onCommitFiberRoot(rendererID, root);
+    });
+    onCommitFiberUnmount = catchErrors(function(fiber) {
+      return hook.onCommitFiberUnmount(rendererID, fiber);
+    });
+  } catch (err) {
+    // Catch all errors because it is unsafe to throw during initialization.
+    {
+      warningWithoutStack$1(
+        false,
+        "React DevTools encountered an error: %s.",
+        err
+      );
+    }
+  }
+  // DevTools exists
+  return true;
+}
+
+function onCommitRoot(root) {
+  if (typeof onCommitFiberRoot === "function") {
+    onCommitFiberRoot(root);
+  }
+}
+
+function onCommitUnmount(fiber) {
+  if (typeof onCommitFiberUnmount === "function") {
+    onCommitFiberUnmount(fiber);
+  }
+}
+
 // Max 31 bit integer. The max integer size in V8 for 32-bit systems.
 // Math.pow(2, 30) - 1
 // 0b111111111111111111111111111111
-var MAX_SIGNED_31_BIT_INT = 1073741823;
+var maxSigned31BitInt = 1073741823;
 
 var NoWork = 0;
 var Sync = 1;
-var Never = MAX_SIGNED_31_BIT_INT;
+var Never = maxSigned31BitInt;
 
 var UNIT_SIZE = 10;
 var MAGIC_NUMBER_OFFSET = 2;
@@ -5075,6 +5255,39 @@ function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
   );
 }
 
+var LOW_PRIORITY_EXPIRATION = 5000;
+var LOW_PRIORITY_BATCH_SIZE = 250;
+
+function computeAsyncExpiration(currentTime) {
+  return computeExpirationBucket(
+    currentTime,
+    LOW_PRIORITY_EXPIRATION,
+    LOW_PRIORITY_BATCH_SIZE
+  );
+}
+
+// We intentionally set a higher expiration time for interactive updates in
+// dev than in production.
+//
+// If the main thread is being blocked so long that you hit the expiration,
+// it's a problem that could be solved with better scheduling.
+//
+// People will be more likely to notice this and fix it with the long
+// expiration time in development.
+//
+// In production we opt for better UX at the risk of masking scheduling
+// problems, by expiring fast.
+var HIGH_PRIORITY_EXPIRATION = 500;
+var HIGH_PRIORITY_BATCH_SIZE = 100;
+
+function computeInteractiveExpiration(currentTime) {
+  return computeExpirationBucket(
+    currentTime,
+    HIGH_PRIORITY_EXPIRATION,
+    HIGH_PRIORITY_BATCH_SIZE
+  );
+}
+
 var NoContext = 0;
 var AsyncMode = 1;
 var StrictMode = 2;
@@ -5127,6 +5340,7 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.memoizedProps = null;
   this.updateQueue = null;
   this.memoizedState = null;
+  this.firstContextDependency = null;
 
   this.mode = mode;
 
@@ -5138,14 +5352,15 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.lastEffect = null;
 
   this.expirationTime = NoWork;
+  this.childExpirationTime = NoWork;
 
   this.alternate = null;
 
   if (enableProfilerTimer) {
     this.actualDuration = 0;
     this.actualStartTime = 0;
-    this.selfBaseTime = 0;
-    this.treeBaseTime = 0;
+    this.selfBaseDuration = 0;
+    this.treeBaseDuration = 0;
   }
 
   {
@@ -5230,12 +5445,21 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
     }
   }
 
-  workInProgress.expirationTime = expirationTime;
+  // Don't touching the subtree's expiration time, which has not changed.
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  if (pendingProps !== current.pendingProps) {
+    // This fiber has new props.
+    workInProgress.expirationTime = expirationTime;
+  } else {
+    // This fiber's props have not changed.
+    workInProgress.expirationTime = current.expirationTime;
+  }
 
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
 
   // These will be overridden during the parent's reconciliation
   workInProgress.sibling = current.sibling;
@@ -5243,8 +5467,8 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
   workInProgress.ref = current.ref;
 
   if (enableProfilerTimer) {
-    workInProgress.selfBaseTime = current.selfBaseTime;
-    workInProgress.treeBaseTime = current.treeBaseTime;
+    workInProgress.selfBaseDuration = current.selfBaseDuration;
+    workInProgress.treeBaseDuration = current.treeBaseDuration;
   }
 
   return workInProgress;
@@ -5252,6 +5476,14 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
 
 function createHostRootFiber(isAsync) {
   var mode = isAsync ? AsyncMode | StrictMode : NoContext;
+
+  if (enableProfilerTimer && isDevToolsPresent) {
+    // Always collect profile timings when DevTools are present.
+    // This enables DevTools to start capturing timing at any point–
+    // Without some nodes in the tree having empty base times.
+    mode |= ProfileMode;
+  }
+
   return createFiber(HostRoot, null, null, mode);
 }
 
@@ -5290,11 +5522,8 @@ function createFiberFromElement(element, mode, expirationTime) {
         break;
       case REACT_PROFILER_TYPE:
         return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
-      case REACT_TIMEOUT_TYPE:
-        fiberTag = TimeoutComponent;
-        // Suspense does not require async, but its children should be strict
-        // mode compatible.
-        mode |= StrictMode;
+      case REACT_PLACEHOLDER_TYPE:
+        fiberTag = PlaceholderComponent;
         break;
       default:
         fiberTag = getFiberTagFromObjectType(type, owner);
@@ -5340,7 +5569,7 @@ function getFiberTagFromObjectType(type, owner) {
             "it's defined in, or you might have mixed up default and " +
             "named imports.";
         }
-        var ownerName = owner ? getComponentName(owner) : null;
+        var ownerName = owner ? getComponentName(owner.type) : null;
         if (ownerName) {
           info += "\n\nCheck the render method of `" + ownerName + "`.";
         }
@@ -5434,18 +5663,20 @@ function assignFiberPropertiesInDEV(target, source) {
   target.memoizedProps = source.memoizedProps;
   target.updateQueue = source.updateQueue;
   target.memoizedState = source.memoizedState;
+  target.firstContextDependency = source.firstContextDependency;
   target.mode = source.mode;
   target.effectTag = source.effectTag;
   target.nextEffect = source.nextEffect;
   target.firstEffect = source.firstEffect;
   target.lastEffect = source.lastEffect;
   target.expirationTime = source.expirationTime;
+  target.childExpirationTime = source.childExpirationTime;
   target.alternate = source.alternate;
   if (enableProfilerTimer) {
     target.actualDuration = source.actualDuration;
     target.actualStartTime = source.actualStartTime;
-    target.selfBaseTime = source.selfBaseTime;
-    target.treeBaseTime = source.treeBaseTime;
+    target.selfBaseDuration = source.selfBaseDuration;
+    target.treeBaseDuration = source.treeBaseDuration;
   }
   target._debugID = source._debugID;
   target._debugSource = source._debugSource;
@@ -5475,6 +5706,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
 
     pendingCommitExpirationTime: NoWork,
     finishedWork: null,
+    timeoutHandle: noTimeout,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -5487,78 +5719,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   return root;
 }
 
-var onCommitFiberRoot = null;
-var onCommitFiberUnmount = null;
-var hasLoggedError = false;
-
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {
-      if (true && !hasLoggedError) {
-        hasLoggedError = true;
-        warning(false, "React DevTools encountered an error: %s", err);
-      }
-    }
-  };
-}
-
-function injectInternals(internals) {
-  if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
-    // No DevTools
-    return false;
-  }
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled) {
-    // This isn't a real property on the hook, but it can be set to opt out
-    // of DevTools integration and associated warnings and logs.
-    // https://github.com/facebook/react/issues/3877
-    return true;
-  }
-  if (!hook.supportsFiber) {
-    {
-      warning(
-        false,
-        "The installed version of React DevTools is too old and will not work " +
-          "with the current version of React. Please update React DevTools. " +
-          "https://fb.me/react-devtools"
-      );
-    }
-    // DevTools exists, even though it doesn't support Fiber.
-    return true;
-  }
-  try {
-    var rendererID = hook.inject(internals);
-    // We have successfully injected, so now it is safe to set up hooks.
-    onCommitFiberRoot = catchErrors(function(root) {
-      return hook.onCommitFiberRoot(rendererID, root);
-    });
-    onCommitFiberUnmount = catchErrors(function(fiber) {
-      return hook.onCommitFiberUnmount(rendererID, fiber);
-    });
-  } catch (err) {
-    // Catch all errors because it is unsafe to throw during initialization.
-    {
-      warning(false, "React DevTools encountered an error: %s.", err);
-    }
-  }
-  // DevTools exists
-  return true;
-}
-
-function onCommitRoot(root) {
-  if (typeof onCommitFiberRoot === "function") {
-    onCommitFiberRoot(root);
-  }
-}
-
-function onCommitUnmount(fiber) {
-  if (typeof onCommitFiberUnmount === "function") {
-    onCommitFiberUnmount(fiber);
-  }
-}
-
 /**
  * Forked from fbjs/warning:
  * https://github.com/facebook/fbjs/blob/e66ba20ad5be433eb54423f2b097d829324d9de6/packages/fbjs/src/__forks__/warning.js
@@ -5607,7 +5767,7 @@ var lowPriorityWarning = function() {};
   lowPriorityWarning = function(condition, format) {
     if (format === undefined) {
       throw new Error(
-        "`warning(condition, format, ...args)` requires a warning " +
+        "`lowPriorityWarning(condition, format, ...args)` requires a warning " +
           "message argument"
       );
     }
@@ -5685,7 +5845,7 @@ var ReactStrictModeWarnings = {
         if (lifecycleWarnings.length > 0) {
           var componentNames = new Set();
           lifecycleWarnings.forEach(function(fiber) {
-            componentNames.add(getComponentName(fiber) || "Component");
+            componentNames.add(getComponentName(fiber.type) || "Component");
             didWarnAboutUnsafeLifecycles.add(fiber.type);
           });
 
@@ -5702,11 +5862,9 @@ var ReactStrictModeWarnings = {
       });
 
       if (lifecyclesWarningMesages.length > 0) {
-        var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(
-          strictRoot
-        );
+        var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
 
-        warning(
+        warningWithoutStack$1(
           false,
           "Unsafe lifecycle methods were found within a strict-mode tree:%s" +
             "\n\n%s" +
@@ -5739,7 +5897,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillMountWarnings.length > 0) {
       var uniqueNames = new Set();
       pendingComponentWillMountWarnings.forEach(function(fiber) {
-        uniqueNames.add(getComponentName(fiber) || "Component");
+        uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5762,7 +5920,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillReceivePropsWarnings.length > 0) {
       var _uniqueNames = new Set();
       pendingComponentWillReceivePropsWarnings.forEach(function(fiber) {
-        _uniqueNames.add(getComponentName(fiber) || "Component");
+        _uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5784,7 +5942,7 @@ var ReactStrictModeWarnings = {
     if (pendingComponentWillUpdateWarnings.length > 0) {
       var _uniqueNames2 = new Set();
       pendingComponentWillUpdateWarnings.forEach(function(fiber) {
-        _uniqueNames2.add(getComponentName(fiber) || "Component");
+        _uniqueNames2.add(getComponentName(fiber.type) || "Component");
         didWarnAboutDeprecatedLifecycles.add(fiber.type);
       });
 
@@ -5841,7 +5999,7 @@ var ReactStrictModeWarnings = {
   ) {
     var strictRoot = findStrictRoot(fiber);
     if (strictRoot === null) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected to find a StrictMode component in a strict mode tree. " +
           "This error is likely caused by a bug in React. Please file an issue."
@@ -5908,7 +6066,7 @@ var ReactStrictModeWarnings = {
   ) {
     var strictRoot = findStrictRoot(fiber);
     if (strictRoot === null) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Expected to find a StrictMode component in a strict mode tree. " +
           "This error is likely caused by a bug in React. Please file an issue."
@@ -5940,16 +6098,14 @@ var ReactStrictModeWarnings = {
     pendingLegacyContextWarning.forEach(function(fiberArray, strictRoot) {
       var uniqueNames = new Set();
       fiberArray.forEach(function(fiber) {
-        uniqueNames.add(getComponentName(fiber) || "Component");
+        uniqueNames.add(getComponentName(fiber.type) || "Component");
         didWarnAboutLegacyContext.add(fiber.type);
       });
 
       var sortedNames = setToSortedString(uniqueNames);
-      var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(
-        strictRoot
-      );
+      var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
 
-      warning(
+      warningWithoutStack$1(
         false,
         "Legacy context API has been detected within a strict-mode tree: %s" +
           "\n\nPlease update the following components: %s" +
@@ -5972,7 +6128,9 @@ var ReactFiberInstrumentation = {
 
 var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;
 
-// TODO: Offscreen updates
+// TODO: Offscreen updates should never suspend. However, a promise that
+// suspended inside an offscreen subtree should be able to ping at the priority
+// of the outer render.
 
 function markPendingPriorityLevel(root, expirationTime) {
   // If there's a gap between completing a failed root and retrying it,
@@ -5997,10 +6155,10 @@ function markPendingPriorityLevel(root, expirationTime) {
       }
     }
   }
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
 
-function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
+function markCommittedPriorityLevels(root, earliestRemainingTime) {
   root.didError = false;
 
   if (earliestRemainingTime === NoWork) {
@@ -6010,7 +6168,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     root.earliestSuspendedTime = NoWork;
     root.latestSuspendedTime = NoWork;
     root.latestPingedTime = NoWork;
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -6039,7 +6197,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // There's no suspended work. Treat the earliest remaining level as a
     // pending level.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -6054,7 +6212,7 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // There's no suspended work. Treat the earliest remaining level as a
     // pending level.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
@@ -6062,31 +6220,41 @@ function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
     // The earliest remaining time is earlier than all the suspended work.
     // Treat it as a pending update.
     markPendingPriorityLevel(root, earliestRemainingTime);
-    findNextPendingPriorityLevel(root);
+    findNextExpirationTimeToWorkOn(NoWork, root);
     return;
   }
 
   // The earliest remaining time falls within the range of known suspended
   // levels. We should treat this as suspended work.
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(NoWork, root);
 }
 
-function hasLowerPriorityWork(root, renderExpirationTime) {
+function hasLowerPriorityWork(root, erroredExpirationTime) {
+  var latestPendingTime = root.latestPendingTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  var latestPingedTime = root.latestPingedTime;
   return (
-    renderExpirationTime !== root.latestPendingTime &&
-    renderExpirationTime !== root.latestSuspendedTime
+    (latestPendingTime !== NoWork &&
+      latestPendingTime > erroredExpirationTime) ||
+    (latestSuspendedTime !== NoWork &&
+      latestSuspendedTime > erroredExpirationTime) ||
+    (latestPingedTime !== NoWork && latestPingedTime > erroredExpirationTime)
   );
 }
 
-function markSuspendedPriorityLevel(root, suspendedTime, didError) {
-  if (didError && !hasLowerPriorityWork(root, suspendedTime)) {
-    // TODO: When we add back resuming, we need to ensure the progressed work
-    // is thrown out and not reused during the restarted render. One way to
-    // invalidate the progressed work is to restart at expirationTime + 1.
-    root.didError = true;
-    findNextPendingPriorityLevel(root);
-    return;
-  }
+function isPriorityLevelSuspended(root, expirationTime) {
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  return (
+    earliestSuspendedTime !== NoWork &&
+    expirationTime >= earliestSuspendedTime &&
+    expirationTime <= latestSuspendedTime
+  );
+}
+
+function markSuspendedPriorityLevel(root, suspendedTime) {
+  root.didError = false;
+  clearPing(root, suspendedTime);
 
   // First, check the known pending levels and update them if needed.
   var earliestPendingTime = root.earliestPendingTime;
@@ -6106,15 +6274,9 @@ function markSuspendedPriorityLevel(root, suspendedTime, didError) {
     root.latestPendingTime = earliestPendingTime;
   }
 
-  // Next, if we're working on the lowest known suspended level, clear the ping.
-  // TODO: What if a promise suspends and pings before the root completes?
-  var latestSuspendedTime = root.latestSuspendedTime;
-  if (latestSuspendedTime === suspendedTime) {
-    root.latestPingedTime = NoWork;
-  }
-
   // Finally, update the known suspended levels.
   var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
   if (earliestSuspendedTime === NoWork) {
     // No other suspended levels.
     root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
@@ -6127,44 +6289,86 @@ function markSuspendedPriorityLevel(root, suspendedTime, didError) {
       root.latestSuspendedTime = suspendedTime;
     }
   }
-  findNextPendingPriorityLevel(root);
+
+  findNextExpirationTimeToWorkOn(suspendedTime, root);
 }
 
 function markPingedPriorityLevel(root, pingedTime) {
-  var latestSuspendedTime = root.latestSuspendedTime;
-  if (latestSuspendedTime !== NoWork && latestSuspendedTime <= pingedTime) {
-    var latestPingedTime = root.latestPingedTime;
-    if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
-      root.latestPingedTime = pingedTime;
-    }
+  root.didError = false;
+
+  // TODO: When we add back resuming, we need to ensure the progressed work
+  // is thrown out and not reused during the restarted render. One way to
+  // invalidate the progressed work is to restart at expirationTime + 1.
+  var latestPingedTime = root.latestPingedTime;
+  if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
+    root.latestPingedTime = pingedTime;
   }
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(pingedTime, root);
 }
 
-function findNextPendingPriorityLevel(root) {
-  var earliestSuspendedTime = root.earliestSuspendedTime;
+function clearPing(root, completedTime) {
+  // TODO: Track whether the root was pinged during the render phase. If so,
+  // we need to make sure we don't lose track of it.
+  var latestPingedTime = root.latestPingedTime;
+  if (latestPingedTime !== NoWork && latestPingedTime <= completedTime) {
+    root.latestPingedTime = NoWork;
+  }
+}
+
+function findEarliestOutstandingPriorityLevel(root, renderExpirationTime) {
+  var earliestExpirationTime = renderExpirationTime;
+
   var earliestPendingTime = root.earliestPendingTime;
-  var nextExpirationTimeToWorkOn = void 0;
-  var expirationTime = void 0;
-  if (earliestSuspendedTime === NoWork) {
-    // Fast path. There's no suspended work.
-    nextExpirationTimeToWorkOn = expirationTime = earliestPendingTime;
-  } else if (earliestPendingTime !== NoWork) {
-    // Check if there's known pending work.
-    nextExpirationTimeToWorkOn = earliestPendingTime;
-    expirationTime =
-      earliestSuspendedTime < earliestPendingTime
-        ? earliestSuspendedTime
-        : earliestPendingTime;
-  } else {
-    // Finally, if a suspended level was pinged, work on that. Otherwise there's
-    // nothing to work on.
-    nextExpirationTimeToWorkOn = expirationTime = root.latestPingedTime;
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  if (
+    earliestExpirationTime === NoWork ||
+    (earliestPendingTime !== NoWork &&
+      earliestPendingTime < earliestExpirationTime)
+  ) {
+    earliestExpirationTime = earliestPendingTime;
+  }
+  if (
+    earliestExpirationTime === NoWork ||
+    (earliestSuspendedTime !== NoWork &&
+      earliestSuspendedTime < earliestExpirationTime)
+  ) {
+    earliestExpirationTime = earliestSuspendedTime;
+  }
+  return earliestExpirationTime;
+}
+
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
+  var earliestSuspendedTime = root.earliestSuspendedTime;
+  var latestSuspendedTime = root.latestSuspendedTime;
+  var earliestPendingTime = root.earliestPendingTime;
+  var latestPingedTime = root.latestPingedTime;
+
+  // Work on the earliest pending time. Failing that, work on the latest
+  // pinged time.
+  var nextExpirationTimeToWorkOn =
+    earliestPendingTime !== NoWork ? earliestPendingTime : latestPingedTime;
+
+  // If there is no pending or pinted work, check if there's suspended work
+  // that's lower priority than what we just completed.
+  if (
+    nextExpirationTimeToWorkOn === NoWork &&
+    (completedExpirationTime === NoWork ||
+      latestSuspendedTime > completedExpirationTime)
+  ) {
+    // The lowest priority suspended work is the work most likely to be
+    // committed next. Let's start rendering it again, so that if it times out,
+    // it's ready to commit.
+    nextExpirationTimeToWorkOn = latestSuspendedTime;
   }
 
-  if (root.didError) {
-    // Revert to synchronous mode.
-    expirationTime = Sync;
+  var expirationTime = nextExpirationTimeToWorkOn;
+  if (
+    expirationTime !== NoWork &&
+    earliestSuspendedTime !== NoWork &&
+    earliestSuspendedTime < expirationTime
+  ) {
+    // Expire using the earliest known expiration time.
+    expirationTime = earliestSuspendedTime;
   }
 
   root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
@@ -6271,7 +6475,6 @@ var resetCurrentlyProcessingQueue = void 0;
 
 function createUpdateQueue(baseState) {
   var queue = {
-    expirationTime: NoWork,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -6287,7 +6490,6 @@ function createUpdateQueue(baseState) {
 
 function cloneUpdateQueue(currentQueue) {
   var queue = {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -6319,7 +6521,7 @@ function createUpdate(expirationTime) {
   };
 }
 
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   // Append the update to the end of the list.
   if (queue.lastUpdate === null) {
     // Queue is empty
@@ -6328,17 +6530,9 @@ function appendUpdateToQueue(queue, update, expirationTime) {
     queue.lastUpdate.next = update;
     queue.lastUpdate = update;
   }
-  if (
-    queue.expirationTime === NoWork ||
-    queue.expirationTime > expirationTime
-  ) {
-    // The incoming update has the earliest expiration of any update in the
-    // queue. Update the queue's expiration time.
-    queue.expirationTime = expirationTime;
-  }
 }
 
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   // Update queues are created lazily.
   var alternate = fiber.alternate;
   var queue1 = void 0;
@@ -6376,19 +6570,19 @@ function enqueueUpdate(fiber, update, expirationTime) {
   }
   if (queue2 === null || queue1 === queue2) {
     // There's only a single queue.
-    appendUpdateToQueue(queue1, update, expirationTime);
+    appendUpdateToQueue(queue1, update);
   } else {
     // There are two queues. We need to append the update to both queues,
     // while accounting for the persistent structure of the list — we don't
     // want the same update to be added multiple times.
     if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
       // One of the queues is not empty. We must add the update to both queues.
-      appendUpdateToQueue(queue1, update, expirationTime);
-      appendUpdateToQueue(queue2, update, expirationTime);
+      appendUpdateToQueue(queue1, update);
+      appendUpdateToQueue(queue2, update);
     } else {
       // Both queues are non-empty. The last update is the same in both lists,
       // because of structural sharing. So, only append to one of the lists.
-      appendUpdateToQueue(queue1, update, expirationTime);
+      appendUpdateToQueue(queue1, update);
       // But we still need to update the `lastUpdate` pointer of queue2.
       queue2.lastUpdate = update;
     }
@@ -6401,7 +6595,7 @@ function enqueueUpdate(fiber, update, expirationTime) {
         (queue2 !== null && currentlyProcessingQueue === queue2)) &&
       !didWarnUpdateInsideUpdate
     ) {
-      warning(
+      warningWithoutStack$1(
         false,
         "An update (setState, replaceState, or forceUpdate) was scheduled " +
           "from inside an update function. Update functions should be pure, " +
@@ -6413,7 +6607,7 @@ function enqueueUpdate(fiber, update, expirationTime) {
   }
 }
 
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   // Captured updates go into a separate list, and only on the work-in-
   // progress queue.
   var workInProgressQueue = workInProgress.updateQueue;
@@ -6439,14 +6633,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     workInProgressQueue.lastCapturedUpdate.next = update;
     workInProgressQueue.lastCapturedUpdate = update;
   }
-  if (
-    workInProgressQueue.expirationTime === NoWork ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  ) {
-    // The incoming update has the earliest expiration of any update in the
-    // queue. Update the queue's expiration time.
-    workInProgressQueue.expirationTime = renderExpirationTime;
-  }
 }
 
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
@@ -6536,14 +6722,6 @@ function processUpdateQueue(
 ) {
   hasForceUpdate = false;
 
-  if (
-    queue.expirationTime === NoWork ||
-    queue.expirationTime > renderExpirationTime
-  ) {
-    // Insufficient priority. Bailout.
-    return;
-  }
-
   queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
 
   {
@@ -6675,8 +6853,15 @@ function processUpdateQueue(
   queue.baseState = newBaseState;
   queue.firstUpdate = newFirstUpdate;
   queue.firstCapturedUpdate = newFirstCapturedUpdate;
-  queue.expirationTime = newExpirationTime;
 
+  // Set the remaining expiration time to be whatever is remaining in the queue.
+  // This should be fine because the only two other things that contribute to
+  // expiration time are props and context. We're already in the middle of the
+  // begin phase by the time we start processing the queue, so we've already
+  // dealt with the props. Context in components that specify
+  // shouldComponentUpdate is tricky; but we'll have to account for
+  // that regardless.
+  workInProgress.expirationTime = newExpirationTime;
   workInProgress.memoizedState = resultState;
 
   {
@@ -6752,11 +6937,10 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
 
-var providerCursor = createCursor(null);
 var valueCursor = createCursor(null);
 var changedBitsCursor = createCursor(0);
 
@@ -6766,13 +6950,24 @@ var rendererSigil = void 0;
   rendererSigil = {};
 }
 
+var currentlyRenderingFiber = null;
+var lastContextDependency = null;
+var lastContextWithAllBitsObserved = null;
+
+function resetContextDependences() {
+  // This is called right before React yields execution, to ensure `readContext`
+  // cannot be called outside the render phase.
+  currentlyRenderingFiber = null;
+  lastContextDependency = null;
+  lastContextWithAllBitsObserved = null;
+}
+
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
 
   if (isPrimaryRenderer) {
     push(changedBitsCursor, context._changedBits, providerFiber);
     push(valueCursor, context._currentValue, providerFiber);
-    push(providerCursor, providerFiber, providerFiber);
 
     context._currentValue = providerFiber.pendingProps.value;
     context._changedBits = providerFiber.stateNode;
@@ -6782,7 +6977,7 @@ function pushProvider(providerFiber) {
         context._currentRenderer === null ||
         context._currentRenderer === rendererSigil
       )
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "Detected multiple renderers concurrently rendering the " +
               "same context provider. This is currently unsupported."
@@ -6793,7 +6988,6 @@ function pushProvider(providerFiber) {
   } else {
     push(changedBitsCursor, context._changedBits2, providerFiber);
     push(valueCursor, context._currentValue2, providerFiber);
-    push(providerCursor, providerFiber, providerFiber);
 
     context._currentValue2 = providerFiber.pendingProps.value;
     context._changedBits2 = providerFiber.stateNode;
@@ -6803,7 +6997,7 @@ function pushProvider(providerFiber) {
         context._currentRenderer2 === null ||
         context._currentRenderer2 === rendererSigil
       )
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "Detected multiple renderers concurrently rendering the " +
               "same context provider. This is currently unsupported."
@@ -6818,7 +7012,6 @@ function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current;
   var currentValue = valueCursor.current;
 
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
 
@@ -6832,12 +7025,198 @@ function popProvider(providerFiber) {
   }
 }
 
-function getContextCurrentValue(context) {
-  return isPrimaryRenderer ? context._currentValue : context._currentValue2;
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  if (fiber !== null) {
+    // Set the return pointer of the child to the work-in-progress fiber.
+    fiber.return = workInProgress;
+  }
+  while (fiber !== null) {
+    var nextFiber = void 0;
+
+    // Visit this fiber.
+    var dependency = fiber.firstContextDependency;
+    if (dependency !== null) {
+      do {
+        // Check if the context matches.
+        if (
+          dependency.context === context &&
+          (dependency.observedBits & changedBits) !== 0
+        ) {
+          // Match! Schedule an update on this fiber.
+          if (
+            fiber.expirationTime === NoWork ||
+            fiber.expirationTime > renderExpirationTime
+          ) {
+            fiber.expirationTime = renderExpirationTime;
+          }
+          var alternate = fiber.alternate;
+          if (
+            alternate !== null &&
+            (alternate.expirationTime === NoWork ||
+              alternate.expirationTime > renderExpirationTime)
+          ) {
+            alternate.expirationTime = renderExpirationTime;
+          }
+          // Update the child expiration time of all the ancestors, including
+          // the alternates.
+          var node = fiber.return;
+          while (node !== null) {
+            alternate = node.alternate;
+            if (
+              node.childExpirationTime === NoWork ||
+              node.childExpirationTime > renderExpirationTime
+            ) {
+              node.childExpirationTime = renderExpirationTime;
+              if (
+                alternate !== null &&
+                (alternate.childExpirationTime === NoWork ||
+                  alternate.childExpirationTime > renderExpirationTime)
+              ) {
+                alternate.childExpirationTime = renderExpirationTime;
+              }
+            } else if (
+              alternate !== null &&
+              (alternate.childExpirationTime === NoWork ||
+                alternate.childExpirationTime > renderExpirationTime)
+            ) {
+              alternate.childExpirationTime = renderExpirationTime;
+            } else {
+              // Neither alternate was updated, which means the rest of the
+              // ancestor path already has sufficient priority.
+              break;
+            }
+            node = node.return;
+          }
+          // Don't scan deeper than a matching consumer. When we render the
+          // consumer, we'll continue scanning from that point. This way the
+          // scanning work is time-sliced.
+          nextFiber = null;
+        } else {
+          nextFiber = fiber.child;
+        }
+        dependency = dependency.next;
+      } while (dependency !== null);
+    } else if (fiber.tag === ContextProvider) {
+      // Don't scan deeper if this is a matching provider
+      nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
+    } else {
+      // Traverse down.
+      nextFiber = fiber.child;
+    }
+
+    if (nextFiber !== null) {
+      // Set the return pointer of the child to the work-in-progress fiber.
+      nextFiber.return = fiber;
+    } else {
+      // No child. Traverse to next sibling.
+      nextFiber = fiber;
+      while (nextFiber !== null) {
+        if (nextFiber === workInProgress) {
+          // We're back to the root of this subtree. Exit.
+          nextFiber = null;
+          break;
+        }
+        var sibling = nextFiber.sibling;
+        if (sibling !== null) {
+          // Set the return pointer of the sibling to the work-in-progress fiber.
+          sibling.return = nextFiber.return;
+          nextFiber = sibling;
+          break;
+        }
+        // No more siblings. Traverse up.
+        nextFiber = nextFiber.return;
+      }
+    }
+    fiber = nextFiber;
+  }
 }
 
-function getContextChangedBits(context) {
-  return isPrimaryRenderer ? context._changedBits : context._changedBits2;
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextDependency = null;
+  lastContextWithAllBitsObserved = null;
+
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (firstContextDependency !== null) {
+    // Reset the work-in-progress list
+    workInProgress.firstContextDependency = null;
+
+    // Iterate through the context dependencies and see if there were any
+    // changes. If so, continue propagating the context change by scanning
+    // the child subtree.
+    var dependency = firstContextDependency;
+    var hasPendingContext = false;
+    do {
+      var _context = dependency.context;
+      var changedBits = isPrimaryRenderer
+        ? _context._changedBits
+        : _context._changedBits2;
+      if (changedBits !== 0) {
+        // Resume context change propagation. We need to call this even if
+        // this fiber bails out, in case deeply nested consumers observe more
+        // bits than this one.
+        propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        );
+        if ((changedBits & dependency.observedBits) !== 0) {
+          hasPendingContext = true;
+        }
+      }
+      dependency = dependency.next;
+    } while (dependency !== null);
+    return hasPendingContext;
+  } else {
+    return false;
+  }
+}
+
+function readContext(context, observedBits) {
+  if (lastContextWithAllBitsObserved === context) {
+    // Nothing to do. We already observe everything in this context.
+  } else if (observedBits === false || observedBits === 0) {
+    // Do not observe any updates.
+  } else {
+    var resolvedObservedBits = void 0; // Avoid deopting on observable arguments or heterogeneous types.
+    if (
+      typeof observedBits !== "number" ||
+      observedBits === maxSigned31BitInt
+    ) {
+      // Observe all updates.
+      lastContextWithAllBitsObserved = context;
+      resolvedObservedBits = maxSigned31BitInt;
+    } else {
+      resolvedObservedBits = observedBits;
+    }
+
+    var contextItem = {
+      context: context,
+      observedBits: resolvedObservedBits,
+      next: null
+    };
+
+    if (lastContextDependency === null) {
+      invariant(
+        currentlyRenderingFiber !== null,
+        "Context.unstable_read(): Context can only be read while React is " +
+          "rendering, e.g. inside the render method or getDerivedStateFromProps."
+      );
+      // This is the first dependency in the list
+      currentlyRenderingFiber.firstContextDependency = lastContextDependency = contextItem;
+    } else {
+      // Append a new context item.
+      lastContextDependency = lastContextDependency.next = contextItem;
+    }
+  }
+  return isPrimaryRenderer ? context._currentValue : context._currentValue2;
 }
 
 var NO_CONTEXT = {};
@@ -6944,6 +7323,7 @@ var fiberStack$1 = void 0;
   fiberStack$1 = [];
 }
 
+var syncCommitStartTime = 0;
 var timerPausedAt = 0;
 var totalElapsedPauseTime = 0;
 
@@ -6953,7 +7333,7 @@ function checkActualRenderTimeStackEmpty() {
   }
   {
     !(fiberStack$1.length === 0)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Expected an empty stack. Something was not reset properly."
         )
@@ -6980,6 +7360,14 @@ function pauseActualRenderTimerIfRunning() {
   if (timerPausedAt === 0) {
     timerPausedAt = now();
   }
+  if (syncCommitStartTime > 0) {
+    // Don't count the time spent processing sycn work,
+    // Against yielded async work that will be resumed later.
+    totalElapsedPauseTime += now() - syncCommitStartTime;
+    syncCommitStartTime = 0;
+  } else {
+    totalElapsedPauseTime = 0;
+  }
 }
 
 function recordElapsedActualRenderTime(fiber) {
@@ -6988,23 +7376,23 @@ function recordElapsedActualRenderTime(fiber) {
   }
   {
     !(fiber === fiberStack$1.pop())
-      ? warning(false, "Unexpected Fiber (%s) popped.", getComponentName(fiber))
+      ? warningWithoutStack$1(
+          false,
+          "Unexpected Fiber (%s) popped.",
+          getComponentName(fiber.type)
+        )
       : void 0;
   }
 
   fiber.actualDuration = now() - totalElapsedPauseTime - fiber.actualDuration;
 }
 
-function resetActualRenderTimer() {
+function resumeActualRenderTimerIfPaused(isProcessingSyncWork) {
   if (!enableProfilerTimer) {
     return;
   }
-  totalElapsedPauseTime = 0;
-}
-
-function resumeActualRenderTimerIfPaused() {
-  if (!enableProfilerTimer) {
-    return;
+  if (isProcessingSyncWork && syncCommitStartTime === 0) {
+    syncCommitStartTime = now();
   }
   if (timerPausedAt > 0) {
     totalElapsedPauseTime += now() - timerPausedAt;
@@ -7012,6 +7400,15 @@ function resumeActualRenderTimerIfPaused() {
   }
 }
 
+function resetActualRenderTimerStackAfterFatalErrorInDev() {
+  if (!enableProfilerTimer) {
+    return;
+  }
+  {
+    fiberStack$1.length = 0;
+  }
+}
+
 /**
  * The "base" render time is the duration of the “begin” phase of work for a particular fiber.
  * This time is measured and stored on each fiber.
@@ -7026,7 +7423,7 @@ function recordElapsedBaseRenderTimeIfRunning(fiber) {
     return;
   }
   if (baseStartTime !== -1) {
-    fiber.selfBaseTime = now() - baseStartTime;
+    fiber.selfBaseDuration = now() - baseStartTime;
   }
 }
 
@@ -7036,7 +7433,7 @@ function startBaseRenderTimer() {
   }
   {
     if (baseStartTime !== -1) {
-      warning(
+      warningWithoutStack$1(
         false,
         "Cannot start base timer that is already running. " +
           "This error is likely caused by a bug in React. " +
@@ -7054,6 +7451,43 @@ function stopBaseRenderTimerIfRunning() {
   baseStartTime = -1;
 }
 
+/**
+ * Similar to invariant but only logs a warning if the condition is not met.
+ * This can be used to log issues in development environments in critical
+ * paths. Removing the logging code for production environments will keep the
+ * same logic and follow the same code paths.
+ */
+
+var warning = warningWithoutStack$1;
+
+{
+  warning = function(condition, format) {
+    if (condition) {
+      return;
+    }
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+    // eslint-disable-next-line react-internal/warning-and-invariant-args
+
+    for (
+      var _len = arguments.length,
+        args = Array(_len > 2 ? _len - 2 : 0),
+        _key = 2;
+      _key < _len;
+      _key++
+    ) {
+      args[_key - 2] = arguments[_key];
+    }
+
+    warningWithoutStack$1.apply(
+      undefined,
+      [false, format + "%s"].concat(args, [stack])
+    );
+  };
+}
+
+var warning$1 = warning;
+
 /*eslint-disable no-self-compare */
 
 var hasOwnProperty = Object.prototype.hasOwnProperty;
@@ -7117,6 +7551,10 @@ function shallowEqual(objA, objB) {
 var fakeInternalInstance = {};
 var isArray = Array.isArray;
 
+// React.Component uses a shared frozen object by default.
+// We'll use it to determine whether we need to initialize legacy refs.
+var emptyRefsObject = new React.Component().refs;
+
 var didWarnAboutStateAssignmentForComponent = void 0;
 var didWarnAboutUninitializedState = void 0;
 var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
@@ -7141,7 +7579,7 @@ var warnOnInvalidCallback = void 0;
     var key = callerName + "_" + callback;
     if (!didWarnOnInvalidCallback.has(key)) {
       didWarnOnInvalidCallback.add(key);
-      warning(
+      warningWithoutStack$1(
         false,
         "%s(...): Expected the last optional `callback` argument to be a " +
           "function. Instead received: %s.",
@@ -7151,12 +7589,12 @@ var warnOnInvalidCallback = void 0;
     }
   };
 
-  warnOnUndefinedDerivedState = function(workInProgress, partialState) {
+  warnOnUndefinedDerivedState = function(type, partialState) {
     if (partialState === undefined) {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(type) || "Component";
       if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
         didWarnAboutUndefinedDerivedState.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " +
             "You have returned undefined.",
@@ -7209,7 +7647,7 @@ function applyDerivedStateFromProps(
   var partialState = getDerivedStateFromProps(nextProps, prevState);
 
   {
-    warnOnUndefinedDerivedState(workInProgress, partialState);
+    warnOnUndefinedDerivedState(workInProgress.type, partialState);
   }
   // Merge the partial state and the previous state.
   var memoizedState =
@@ -7221,7 +7659,7 @@ function applyDerivedStateFromProps(
   // Once the update queue is empty, persist the derived state onto the
   // base state.
   var updateQueue = workInProgress.updateQueue;
-  if (updateQueue !== null && updateQueue.expirationTime === NoWork) {
+  if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
     updateQueue.baseState = memoizedState;
   }
 }
@@ -7230,7 +7668,7 @@ var classComponentUpdater = {
   isMounted: isMounted,
   enqueueSetState: function(inst, payload, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -7242,12 +7680,12 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -7261,12 +7699,12 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     var fiber = get$1(inst);
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     var expirationTime = computeExpirationForFiber(currentTime, fiber);
 
     var update = createUpdate(expirationTime);
@@ -7279,7 +7717,7 @@ var classComponentUpdater = {
       update.callback = callback;
     }
 
-    enqueueUpdate(fiber, update, expirationTime);
+    enqueueUpdate(fiber, update);
     scheduleWork(fiber, expirationTime);
   }
 };
@@ -7290,7 +7728,7 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   var ctor = workInProgress.type;
@@ -7299,17 +7737,17 @@ function checkShouldComponentUpdate(
     var shouldUpdate = instance.shouldComponentUpdate(
       newProps,
       newState,
-      newContext
+      nextLegacyContext
     );
     stopPhaseTimer();
 
     {
       !(shouldUpdate !== undefined)
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s.shouldComponentUpdate(): Returned undefined instead of a " +
               "boolean value. Make sure to return true or false.",
-            getComponentName(workInProgress) || "Component"
+            getComponentName(ctor) || "Component"
           )
         : void 0;
     }
@@ -7330,19 +7768,19 @@ function checkClassInstance(workInProgress) {
   var instance = workInProgress.stateNode;
   var type = workInProgress.type;
   {
-    var name = getComponentName(workInProgress) || "Component";
+    var name = getComponentName(type) || "Component";
     var renderPresent = instance.render;
 
     if (!renderPresent) {
       if (type.prototype && typeof type.prototype.render === "function") {
-        warning(
+        warningWithoutStack$1(
           false,
           "%s(...): No `render` method found on the returned component " +
             "instance: did you accidentally return an object from the constructor?",
           name
         );
       } else {
-        warning(
+        warningWithoutStack$1(
           false,
           "%s(...): No `render` method found on the returned component " +
             "instance: you may have forgotten to define `render`.",
@@ -7356,7 +7794,7 @@ function checkClassInstance(workInProgress) {
       instance.getInitialState.isReactClassApproved ||
       instance.state;
     !noGetInitialStateOnES6
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "getInitialState was defined on %s, a plain JavaScript class. " +
             "This is only supported for classes created using React.createClass. " +
@@ -7368,7 +7806,7 @@ function checkClassInstance(workInProgress) {
       !instance.getDefaultProps ||
       instance.getDefaultProps.isReactClassApproved;
     !noGetDefaultPropsOnES6
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "getDefaultProps was defined on %s, a plain JavaScript class. " +
             "This is only supported for classes created using React.createClass. " +
@@ -7378,7 +7816,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstancePropTypes = !instance.propTypes;
     !noInstancePropTypes
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "propTypes was defined as an instance property on %s. Use a static " +
             "property to define propTypes instead.",
@@ -7387,7 +7825,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstanceContextTypes = !instance.contextTypes;
     !noInstanceContextTypes
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "contextTypes was defined as an instance property on %s. Use a static " +
             "property to define contextTypes instead.",
@@ -7397,7 +7835,7 @@ function checkClassInstance(workInProgress) {
     var noComponentShouldUpdate =
       typeof instance.componentShouldUpdate !== "function";
     !noComponentShouldUpdate
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " +
@@ -7411,18 +7849,18 @@ function checkClassInstance(workInProgress) {
       type.prototype.isPureReactComponent &&
       typeof instance.shouldComponentUpdate !== "undefined"
     ) {
-      warning(
+      warningWithoutStack$1(
         false,
         "%s has a method called shouldComponentUpdate(). " +
           "shouldComponentUpdate should not be used when extending React.PureComponent. " +
           "Please extend React.Component if shouldComponentUpdate is used.",
-        getComponentName(workInProgress) || "A pure component"
+        getComponentName(type) || "A pure component"
       );
     }
     var noComponentDidUnmount =
       typeof instance.componentDidUnmount !== "function";
     !noComponentDidUnmount
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentDidUnmount(). But there is no such lifecycle method. " +
@@ -7433,7 +7871,7 @@ function checkClassInstance(workInProgress) {
     var noComponentDidReceiveProps =
       typeof instance.componentDidReceiveProps !== "function";
     !noComponentDidReceiveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentDidReceiveProps(). But there is no such lifecycle method. " +
@@ -7446,7 +7884,7 @@ function checkClassInstance(workInProgress) {
     var noComponentWillRecieveProps =
       typeof instance.componentWillRecieveProps !== "function";
     !noComponentWillRecieveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?",
@@ -7456,7 +7894,7 @@ function checkClassInstance(workInProgress) {
     var noUnsafeComponentWillRecieveProps =
       typeof instance.UNSAFE_componentWillRecieveProps !== "function";
     !noUnsafeComponentWillRecieveProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s has a method called " +
             "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?",
@@ -7465,7 +7903,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var hasMutatedProps = instance.props !== workInProgress.pendingProps;
     !(instance.props === undefined || !hasMutatedProps)
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s(...): When calling super() in `%s`, make sure to pass " +
             "up the same props that your component's constructor was passed.",
@@ -7475,7 +7913,7 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var noInstanceDefaultProps = !instance.defaultProps;
     !noInstanceDefaultProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "Setting defaultProps as an instance property on %s is not supported and will be ignored." +
             " Instead, define defaultProps as a static property on %s.",
@@ -7490,18 +7928,18 @@ function checkClassInstance(workInProgress) {
       !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(type)
     ) {
       didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type);
-      warning(
+      warningWithoutStack$1(
         false,
         "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " +
           "This component defines getSnapshotBeforeUpdate() only.",
-        getComponentName(workInProgress)
+        getComponentName(type)
       );
     }
 
     var noInstanceGetDerivedStateFromProps =
       typeof instance.getDerivedStateFromProps !== "function";
     !noInstanceGetDerivedStateFromProps
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getDerivedStateFromProps() is defined as an instance method " +
             "and will be ignored. Instead, declare it as a static method.",
@@ -7511,7 +7949,7 @@ function checkClassInstance(workInProgress) {
     var noInstanceGetDerivedStateFromCatch =
       typeof instance.getDerivedStateFromCatch !== "function";
     !noInstanceGetDerivedStateFromCatch
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getDerivedStateFromCatch() is defined as an instance method " +
             "and will be ignored. Instead, declare it as a static method.",
@@ -7521,7 +7959,7 @@ function checkClassInstance(workInProgress) {
     var noStaticGetSnapshotBeforeUpdate =
       typeof type.getSnapshotBeforeUpdate !== "function";
     !noStaticGetSnapshotBeforeUpdate
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "%s: getSnapshotBeforeUpdate() is defined as a static method " +
             "and will be ignored. Instead, declare it as an instance method.",
@@ -7530,11 +7968,15 @@ function checkClassInstance(workInProgress) {
       : void 0;
     var _state = instance.state;
     if (_state && (typeof _state !== "object" || isArray(_state))) {
-      warning(false, "%s.state: must be set to an object or null", name);
+      warningWithoutStack$1(
+        false,
+        "%s.state: must be set to an object or null",
+        name
+      );
     }
     if (typeof instance.getChildContext === "function") {
       !(typeof type.childContextTypes === "object")
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%s.getChildContext(): childContextTypes must be defined in order to " +
               "use getChildContext().",
@@ -7561,7 +8003,7 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
   var needsContext = isContextConsumer(workInProgress);
   var context = needsContext
     ? getMaskedContext(workInProgress, unmaskedContext)
-    : emptyObject;
+    : emptyContextObject;
 
   // Instantiate twice to help detect side-effects.
   {
@@ -7583,10 +8025,10 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
 
   {
     if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(ctor) || "Component";
       if (!didWarnAboutUninitializedState.has(componentName)) {
         didWarnAboutUninitializedState.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s: Did not properly initialize state during construction. " +
             "Expected state to be an object, but it was %s.",
@@ -7637,14 +8079,14 @@ function constructClassInstance(workInProgress, props, renderExpirationTime) {
         foundWillReceivePropsName !== null ||
         foundWillUpdateName !== null
       ) {
-        var _componentName = getComponentName(workInProgress) || "Component";
+        var _componentName = getComponentName(ctor) || "Component";
         var newApiName =
           typeof ctor.getDerivedStateFromProps === "function"
             ? "getDerivedStateFromProps()"
             : "getSnapshotBeforeUpdate()";
         if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
           didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
-          warning(
+          warningWithoutStack$1(
             false,
             "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" +
               "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" +
@@ -7687,12 +8129,12 @@ function callComponentWillMount(workInProgress, instance) {
 
   if (oldState !== instance.state) {
     {
-      warning(
+      warningWithoutStack$1(
         false,
         "%s.componentWillMount(): Assigning directly to this.state is " +
           "deprecated (except inside a component's " +
           "constructor). Use setState instead.",
-        getComponentName(workInProgress) || "Component"
+        getComponentName(workInProgress.type) || "Component"
       );
     }
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
@@ -7703,24 +8145,24 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   var oldState = instance.state;
   startPhaseTimer(workInProgress, "componentWillReceiveProps");
   if (typeof instance.componentWillReceiveProps === "function") {
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   }
   if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   }
   stopPhaseTimer();
 
   if (instance.state !== oldState) {
     {
-      var componentName = getComponentName(workInProgress) || "Component";
+      var componentName = getComponentName(workInProgress.type) || "Component";
       if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
         didWarnAboutStateAssignmentForComponent.add(componentName);
-        warning(
+        warningWithoutStack$1(
           false,
           "%s.componentWillReceiveProps(): Assigning directly to " +
             "this.state is deprecated (except inside a component's " +
@@ -7747,7 +8189,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
 
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
 
   {
@@ -7783,7 +8225,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     instance.state = workInProgress.memoizedState;
   }
 
-  var getDerivedStateFromProps = workInProgress.type.getDerivedStateFromProps;
+  var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   if (typeof getDerivedStateFromProps === "function") {
     applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
     instance.state = workInProgress.memoizedState;
@@ -7818,7 +8260,11 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
   }
 }
 
-function resumeMountClassInstance(workInProgress, renderExpirationTime) {
+function resumeMountClassInstance(
+  workInProgress,
+  hasPendingNewContext,
+  renderExpirationTime
+) {
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
@@ -7827,8 +8273,11 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
   instance.props = oldProps;
 
   var oldContext = instance.context;
-  var newUnmaskedContext = getUnmaskedContext(workInProgress);
-  var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
+  var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress);
+  var nextLegacyContext = getMaskedContext(
+    workInProgress,
+    nextLegacyUnmaskedContext
+  );
 
   var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   var hasNewLifecycles =
@@ -7846,12 +8295,12 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
     (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
       typeof instance.componentWillReceiveProps === "function")
   ) {
-    if (oldProps !== newProps || oldContext !== newContext) {
+    if (oldProps !== newProps || oldContext !== nextLegacyContext) {
       callComponentWillReceiveProps(
         workInProgress,
         instance,
         newProps,
-        newContext
+        nextLegacyContext
       );
     }
   }
@@ -7875,6 +8324,7 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
     oldProps === newProps &&
     oldState === newState &&
     !hasContextChanged() &&
+    !hasPendingNewContext &&
     !checkHasForceUpdateAfterProcessing()
   ) {
     // If an update was already in progress, we should schedule an Update
@@ -7896,13 +8346,14 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
 
   var shouldUpdate =
     checkHasForceUpdateAfterProcessing() ||
+    hasPendingNewContext ||
     checkShouldComponentUpdate(
       workInProgress,
       oldProps,
       newProps,
       oldState,
       newState,
-      newContext
+      nextLegacyContext
     );
 
   if (shouldUpdate) {
@@ -7942,13 +8393,18 @@ function resumeMountClassInstance(workInProgress, renderExpirationTime) {
   // if shouldComponentUpdate returns false.
   instance.props = newProps;
   instance.state = newState;
-  instance.context = newContext;
+  instance.context = nextLegacyContext;
 
   return shouldUpdate;
 }
 
 // Invokes the update life-cycles and returns false if it shouldn't rerender.
-function updateClassInstance(current, workInProgress, renderExpirationTime) {
+function updateClassInstance(
+  current,
+  workInProgress,
+  hasPendingNewContext,
+  renderExpirationTime
+) {
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
@@ -7957,8 +8413,11 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
   instance.props = oldProps;
 
   var oldContext = instance.context;
-  var newUnmaskedContext = getUnmaskedContext(workInProgress);
-  var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
+  var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress);
+  var nextLegacyContext = getMaskedContext(
+    workInProgress,
+    nextLegacyUnmaskedContext
+  );
 
   var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
   var hasNewLifecycles =
@@ -7976,12 +8435,12 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     (typeof instance.UNSAFE_componentWillReceiveProps === "function" ||
       typeof instance.componentWillReceiveProps === "function")
   ) {
-    if (oldProps !== newProps || oldContext !== newContext) {
+    if (oldProps !== newProps || oldContext !== nextLegacyContext) {
       callComponentWillReceiveProps(
         workInProgress,
         instance,
         newProps,
-        newContext
+        nextLegacyContext
       );
     }
   }
@@ -8006,6 +8465,7 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     oldProps === newProps &&
     oldState === newState &&
     !hasContextChanged() &&
+    !hasPendingNewContext &&
     !checkHasForceUpdateAfterProcessing()
   ) {
     // If an update was already in progress, we should schedule an Update
@@ -8040,13 +8500,14 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
 
   var shouldUpdate =
     checkHasForceUpdateAfterProcessing() ||
+    hasPendingNewContext ||
     checkShouldComponentUpdate(
       workInProgress,
       oldProps,
       newProps,
       oldState,
       newState,
-      newContext
+      nextLegacyContext
     );
 
   if (shouldUpdate) {
@@ -8059,10 +8520,14 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
     ) {
       startPhaseTimer(workInProgress, "componentWillUpdate");
       if (typeof instance.componentWillUpdate === "function") {
-        instance.componentWillUpdate(newProps, newState, newContext);
+        instance.componentWillUpdate(newProps, newState, nextLegacyContext);
       }
       if (typeof instance.UNSAFE_componentWillUpdate === "function") {
-        instance.UNSAFE_componentWillUpdate(newProps, newState, newContext);
+        instance.UNSAFE_componentWillUpdate(
+          newProps,
+          newState,
+          nextLegacyContext
+        );
       }
       stopPhaseTimer();
     }
@@ -8102,14 +8567,11 @@ function updateClassInstance(current, workInProgress, renderExpirationTime) {
   // if shouldComponentUpdate returns false.
   instance.props = newProps;
   instance.state = newState;
-  instance.context = newContext;
+  instance.context = nextLegacyContext;
 
   return shouldUpdate;
 }
 
-var getCurrentFiberStackAddendum$2 =
-  ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
-
 var didWarnAboutMaps = void 0;
 var didWarnAboutStringRefInStrictMode = void 0;
 var ownerHasKeyUseWarning = void 0;
@@ -8146,25 +8608,24 @@ var warnForMissingKey = function(child) {};
       "Each child in an array or iterator should have a unique " +
       '"key" prop. See https://fb.me/react-warning-keys for ' +
       "more information." +
-      (getCurrentFiberStackAddendum$2() || "");
+      getCurrentFiberStackInDev();
     if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
       return;
     }
     ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
 
-    warning(
+    warning$1(
       false,
       "Each child in an array or iterator should have a unique " +
         '"key" prop. See https://fb.me/react-warning-keys for ' +
-        "more information.%s",
-      getCurrentFiberStackAddendum$2()
+        "more information."
     );
   };
 }
 
 var isArray$1 = Array.isArray;
 
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   var mixedRef = element.ref;
   if (
     mixedRef !== null &&
@@ -8173,9 +8634,9 @@ function coerceRef(returnFiber, current, element) {
   ) {
     {
       if (returnFiber.mode & StrictMode) {
-        var componentName = getComponentName(returnFiber) || "Component";
+        var componentName = getComponentName(returnFiber.type) || "Component";
         if (!didWarnAboutStringRefInStrictMode[componentName]) {
-          warning(
+          warningWithoutStack$1(
             false,
             'A string ref, "%s", has been found within a strict mode tree. ' +
               "String refs are a source of potential bugs and should be avoided. " +
@@ -8184,7 +8645,7 @@ function coerceRef(returnFiber, current, element) {
               "\n\nLearn more about using refs safely here:" +
               "\nhttps://fb.me/react-strict-mode-string-ref",
             mixedRef,
-            getStackAddendumByWorkInProgressFiber(returnFiber)
+            getStackByFiberInDevAndProd(returnFiber)
           );
           didWarnAboutStringRefInStrictMode[componentName] = true;
         }
@@ -8211,15 +8672,19 @@ function coerceRef(returnFiber, current, element) {
       var stringRef = "" + mixedRef;
       // Check if previous string ref matches new string ref
       if (
-        current !== null &&
-        current.ref !== null &&
-        typeof current.ref === "function" &&
-        current.ref._stringRef === stringRef
+        current$$1 !== null &&
+        current$$1.ref !== null &&
+        typeof current$$1.ref === "function" &&
+        current$$1.ref._stringRef === stringRef
       ) {
-        return current.ref;
+        return current$$1.ref;
       }
       var ref = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        var refs = inst.refs;
+        if (refs === emptyRefsObject) {
+          // This is a lazy pooled frozen object, so we need to initialize.
+          refs = inst.refs = {};
+        }
         if (value === null) {
           delete refs[stringRef];
         } else {
@@ -8255,7 +8720,7 @@ function throwOnInvalidObjectType(returnFiber, newChild) {
       addendum =
         " If you meant to render a collection of children, use an array " +
         "instead." +
-        (getCurrentFiberStackAddendum$2() || "");
+        getCurrentFiberStackInDev();
     }
     invariant(
       false,
@@ -8273,19 +8738,18 @@ function warnOnFunctionType() {
     "Functions are not valid as a React child. This may happen if " +
     "you return a Component instead of <Component /> from render. " +
     "Or maybe you meant to call this function rather than return it." +
-    (getCurrentFiberStackAddendum$2() || "");
+    getCurrentFiberStackInDev();
 
   if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
     return;
   }
   ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
 
-  warning(
+  warning$1(
     false,
     "Functions are not valid as a React child. This may happen if " +
       "you return a Component instead of <Component /> from render. " +
-      "Or maybe you meant to call this function rather than return it.%s",
-    getCurrentFiberStackAddendum$2() || ""
+      "Or maybe you meant to call this function rather than return it."
   );
 }
 
@@ -8363,9 +8827,9 @@ function ChildReconciler(shouldTrackSideEffects) {
       // Noop.
       return lastPlacedIndex;
     }
-    var current = newFiber.alternate;
-    if (current !== null) {
-      var oldIndex = current.index;
+    var current$$1 = newFiber.alternate;
+    if (current$$1 !== null) {
+      var oldIndex = current$$1.index;
       if (oldIndex < lastPlacedIndex) {
         // This is a move.
         newFiber.effectTag = Placement;
@@ -8390,8 +8854,13 @@ function ChildReconciler(shouldTrackSideEffects) {
     return newFiber;
   }
 
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (current === null || current.tag !== HostText) {
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (current$$1 === null || current$$1.tag !== HostText) {
       // Insert
       var created = createFiberFromText(
         textContent,
@@ -8402,17 +8871,17 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, textContent, expirationTime);
+      var existing = useFiber(current$$1, textContent, expirationTime);
       existing.return = returnFiber;
       return existing;
     }
   }
 
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (current !== null && current.type === element.type) {
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (current$$1 !== null && current$$1.type === element.type) {
       // Move based on index
-      var existing = useFiber(current, element.props, expirationTime);
-      existing.ref = coerceRef(returnFiber, current, element);
+      var existing = useFiber(current$$1, element.props, expirationTime);
+      existing.ref = coerceRef(returnFiber, current$$1, element);
       existing.return = returnFiber;
       {
         existing._debugSource = element._source;
@@ -8426,18 +8895,18 @@ function ChildReconciler(shouldTrackSideEffects) {
         returnFiber.mode,
         expirationTime
       );
-      created.ref = coerceRef(returnFiber, current, element);
+      created.ref = coerceRef(returnFiber, current$$1, element);
       created.return = returnFiber;
       return created;
     }
   }
 
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      current === null ||
-      current.tag !== HostPortal ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      current$$1 === null ||
+      current$$1.tag !== HostPortal ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     ) {
       // Insert
       var created = createFiberFromPortal(
@@ -8449,14 +8918,24 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, portal.children || [], expirationTime);
+      var existing = useFiber(
+        current$$1,
+        portal.children || [],
+        expirationTime
+      );
       existing.return = returnFiber;
       return existing;
     }
   }
 
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (current === null || current.tag !== Fragment) {
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (current$$1 === null || current$$1.tag !== Fragment) {
       // Insert
       var created = createFiberFromFragment(
         fragment,
@@ -8468,7 +8947,7 @@ function ChildReconciler(shouldTrackSideEffects) {
       return created;
     } else {
       // Update
-      var existing = useFiber(current, fragment, expirationTime);
+      var existing = useFiber(current$$1, fragment, expirationTime);
       existing.return = returnFiber;
       return existing;
     }
@@ -8721,15 +9200,14 @@ function ChildReconciler(shouldTrackSideEffects) {
             knownKeys.add(key);
             break;
           }
-          warning(
+          warning$1(
             false,
             "Encountered two children with the same key, `%s`. " +
               "Keys should be unique so that components maintain their identity " +
               "across updates. Non-unique keys may cause children to be " +
               "duplicated and/or omitted — the behavior is unsupported and " +
-              "could change in a future version.%s",
-            key,
-            getCurrentFiberStackAddendum$2()
+              "could change in a future version.",
+            key
           );
           break;
         default:
@@ -8920,12 +9398,11 @@ function ChildReconciler(shouldTrackSideEffects) {
       // Warn about using Maps as children
       if (newChildrenIterable.entries === iteratorFn) {
         !didWarnAboutMaps
-          ? warning(
+          ? warning$1(
               false,
               "Using Maps as children is unsupported and will likely yield " +
                 "unexpected results. Convert it to a sequence/iterable of keyed " +
-                "ReactElements instead.%s",
-              getCurrentFiberStackAddendum$2()
+                "ReactElements instead."
             )
           : void 0;
         didWarnAboutMaps = true;
@@ -9337,9 +9814,9 @@ function ChildReconciler(shouldTrackSideEffects) {
 var reconcileChildFibers = ChildReconciler(true);
 var mountChildFibers = ChildReconciler(false);
 
-function cloneChildFibers(current, workInProgress) {
+function cloneChildFibers(current$$1, workInProgress) {
   invariant(
-    current === null || workInProgress.child === current.child,
+    current$$1 === null || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
 
@@ -9685,8 +10162,7 @@ function resetHydrationState() {
   isHydrating = false;
 }
 
-var getCurrentFiberStackAddendum$1 =
-  ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
 
 var didWarnAboutBadClass = void 0;
 var didWarnAboutGetDerivedStateOnFunctionalComponent = void 0;
@@ -9698,23 +10174,13 @@ var didWarnAboutStatelessRefs = void 0;
   didWarnAboutStatelessRefs = {};
 }
 
-// TODO: Remove this and use reconcileChildrenAtExpirationTime directly.
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-
-function reconcileChildrenAtExpirationTime(
-  current,
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
-  if (current === null) {
+  if (current$$1 === null) {
     // If this is a fresh new component that hasn't been rendered yet, we
     // won't update its child set by applying minimal side-effects. Instead,
     // we will add them all to the child before it gets rendered. That means
@@ -9734,14 +10200,14 @@ function reconcileChildrenAtExpirationTime(
     // let's throw it out.
     workInProgress.child = reconcileChildFibers(
       workInProgress,
-      current.child,
+      current$$1.child,
       nextChildren,
       renderExpirationTime
     );
   }
 }
 
-function updateForwardRef(current, workInProgress) {
+function updateForwardRef(current$$1, workInProgress, renderExpirationTime) {
   var render = workInProgress.type.render;
   var nextProps = workInProgress.pendingProps;
   var ref = workInProgress.ref;
@@ -9749,119 +10215,132 @@ function updateForwardRef(current, workInProgress) {
     // Normally we can bail out on props equality but if context has changed
     // we don't do the bailout and we have to reuse existing props instead.
   } else if (workInProgress.memoizedProps === nextProps) {
-    var currentRef = current !== null ? current.ref : null;
+    var currentRef = current$$1 !== null ? current$$1.ref : null;
     if (ref === currentRef) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
+      return bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     }
   }
 
   var nextChildren = void 0;
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     nextChildren = render(nextProps, ref);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
 
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateFragment(current, workInProgress) {
+function updateFragment(current$$1, workInProgress, renderExpirationTime) {
   var nextChildren = workInProgress.pendingProps;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (workInProgress.memoizedProps === nextChildren) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextChildren);
   return workInProgress.child;
 }
 
-function updateMode(current, workInProgress) {
+function updateMode(current$$1, workInProgress, renderExpirationTime) {
   var nextChildren = workInProgress.pendingProps.children;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (
-    nextChildren === null ||
-    workInProgress.memoizedProps === nextChildren
-  ) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextChildren);
   return workInProgress.child;
 }
 
-function updateProfiler(current, workInProgress) {
-  var nextProps = workInProgress.pendingProps;
+function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
   if (enableProfilerTimer) {
     workInProgress.effectTag |= Update;
   }
-  if (workInProgress.memoizedProps === nextProps) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
+  var nextProps = workInProgress.pendingProps;
   var nextChildren = nextProps.children;
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (current === null && ref !== null) ||
-    (current !== null && current.ref !== ref)
+    (current$$1 === null && ref !== null) ||
+    (current$$1 !== null && current$$1.ref !== ref)
   ) {
     // Schedule a Ref effect
     workInProgress.effectTag |= Ref;
   }
 }
 
-function updateFunctionalComponent(current, workInProgress) {
+function updateFunctionalComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   var fn = workInProgress.type;
   var nextProps = workInProgress.pendingProps;
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else {
-    if (workInProgress.memoizedProps === nextProps) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    // TODO: consider bringing fn.shouldComponentUpdate() back.
-    // It used to be here.
-  }
-
   var unmaskedContext = getUnmaskedContext(workInProgress);
   var context = getMaskedContext(workInProgress, unmaskedContext);
 
   var nextChildren = void 0;
-
+  prepareToReadContext(workInProgress, renderExpirationTime);
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     nextChildren = fn(nextProps, context);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
+
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateClassComponent(current, workInProgress, renderExpirationTime) {
+function updateClassComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   // Push context providers early to prevent context stack mismatches.
   // During mounting we don't know the child context yet as the instance doesn't exist.
   // We will invalidate the child context in finishClassComponent() right after rendering.
   var hasContext = pushContextProvider(workInProgress);
+  var hasPendingNewContext = prepareToReadContext(
+    workInProgress,
+    renderExpirationTime
+  );
+
   var shouldUpdate = void 0;
-  if (current === null) {
+  if (current$$1 === null) {
     if (workInProgress.stateNode === null) {
       // In the initial pass we might need to construct the instance.
       constructClassInstance(
@@ -9876,18 +10355,20 @@ function updateClassComponent(current, workInProgress, renderExpirationTime) {
       // In a resume, we'll already have an instance we can reuse.
       shouldUpdate = resumeMountClassInstance(
         workInProgress,
+        hasPendingNewContext,
         renderExpirationTime
       );
     }
   } else {
     shouldUpdate = updateClassInstance(
-      current,
+      current$$1,
       workInProgress,
+      hasPendingNewContext,
       renderExpirationTime
     );
   }
   return finishClassComponent(
-    current,
+    current$$1,
     workInProgress,
     shouldUpdate,
     hasContext,
@@ -9896,14 +10377,14 @@ function updateClassComponent(current, workInProgress, renderExpirationTime) {
 }
 
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
   // Refs should update even if shouldComponentUpdate returns false
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
 
   var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;
 
@@ -9913,14 +10394,18 @@ function finishClassComponent(
       invalidateContextProvider(workInProgress, false);
     }
 
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
 
   var ctor = workInProgress.type;
   var instance = workInProgress.stateNode;
 
   // Rerender
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   var nextChildren = void 0;
   if (
     didCaptureError &&
@@ -9939,7 +10424,7 @@ function finishClassComponent(
     }
   } else {
     {
-      ReactDebugCurrentFiber.setCurrentPhase("render");
+      setCurrentPhase("render");
       nextChildren = instance.render();
       if (
         debugRenderPhaseSideEffects ||
@@ -9948,28 +10433,23 @@ function finishClassComponent(
       ) {
         instance.render();
       }
-      ReactDebugCurrentFiber.setCurrentPhase(null);
+      setCurrentPhase(null);
     }
   }
 
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  if (didCaptureError) {
+  if (current$$1 !== null && didCaptureError) {
     // If we're recovering from an error, reconcile twice: first to delete
     // all the existing children.
-    reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    );
+    reconcileChildren(current$$1, workInProgress, null, renderExpirationTime);
     workInProgress.child = null;
     // Now we can continue reconciling like normal. This has the effect of
     // remounting all children regardless of whether their their
     // identity matches.
   }
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -10002,99 +10482,89 @@ function pushHostRootContext(workInProgress) {
   pushHostContainer(workInProgress, root.containerInfo);
 }
 
-function updateHostRoot(current, workInProgress, renderExpirationTime) {
+function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
   pushHostRootContext(workInProgress);
   var updateQueue = workInProgress.updateQueue;
-  if (updateQueue !== null) {
-    var nextProps = workInProgress.pendingProps;
-    var prevState = workInProgress.memoizedState;
-    var prevChildren = prevState !== null ? prevState.element : null;
-    processUpdateQueue(
+  invariant(
+    updateQueue !== null,
+    "If the root does not have an updateQueue, we should have already " +
+      "bailed out. This error is likely caused by a bug in React. Please " +
+      "file an issue."
+  );
+  var nextProps = workInProgress.pendingProps;
+  var prevState = workInProgress.memoizedState;
+  var prevChildren = prevState !== null ? prevState.element : null;
+  processUpdateQueue(
+    workInProgress,
+    updateQueue,
+    nextProps,
+    null,
+    renderExpirationTime
+  );
+  var nextState = workInProgress.memoizedState;
+  // Caution: React DevTools currently depends on this property
+  // being called "element".
+  var nextChildren = nextState.element;
+  if (nextChildren === prevChildren) {
+    // If the state is the same as before, that's a bailout because we had
+    // no work that expires at this time.
+    resetHydrationState();
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
       workInProgress,
-      updateQueue,
-      nextProps,
-      null,
       renderExpirationTime
     );
-    var nextState = workInProgress.memoizedState;
-    // Caution: React DevTools currently depends on this property
-    // being called "element".
-    var nextChildren = nextState.element;
-
-    if (nextChildren === prevChildren) {
-      // If the state is the same as before, that's a bailout because we had
-      // no work that expires at this time.
-      resetHydrationState();
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    var root = workInProgress.stateNode;
-    if (
-      (current === null || current.child === null) &&
-      root.hydrate &&
-      enterHydrationState(workInProgress)
-    ) {
-      // If we don't have any current children this might be the first pass.
-      // We always try to hydrate. If this isn't a hydration pass there won't
-      // be any children to hydrate which is effectively the same thing as
-      // not hydrating.
-
-      // This is a bit of a hack. We track the host root as a placement to
-      // know that we're currently in a mounting state. That way isMounted
-      // works as expected. We must reset this before committing.
-      // TODO: Delete this when we delete isMounted and findDOMNode.
-      workInProgress.effectTag |= Placement;
-
-      // Ensure that children mount into this root without tracking
-      // side-effects. This ensures that we don't store Placement effects on
-      // nodes that will be hydrated.
-      workInProgress.child = mountChildFibers(
-        workInProgress,
-        null,
-        nextChildren,
-        renderExpirationTime
-      );
-    } else {
-      // Otherwise reset hydration state in case we aborted and resumed another
-      // root.
-      resetHydrationState();
-      reconcileChildren(current, workInProgress, nextChildren);
-    }
-    return workInProgress.child;
   }
-  resetHydrationState();
-  // If there is no update queue, that's a bailout because the root has no props.
-  return bailoutOnAlreadyFinishedWork(current, workInProgress);
+  var root = workInProgress.stateNode;
+  if (
+    (current$$1 === null || current$$1.child === null) &&
+    root.hydrate &&
+    enterHydrationState(workInProgress)
+  ) {
+    // If we don't have any current children this might be the first pass.
+    // We always try to hydrate. If this isn't a hydration pass there won't
+    // be any children to hydrate which is effectively the same thing as
+    // not hydrating.
+
+    // This is a bit of a hack. We track the host root as a placement to
+    // know that we're currently in a mounting state. That way isMounted
+    // works as expected. We must reset this before committing.
+    // TODO: Delete this when we delete isMounted and findDOMNode.
+    workInProgress.effectTag |= Placement;
+
+    // Ensure that children mount into this root without tracking
+    // side-effects. This ensures that we don't store Placement effects on
+    // nodes that will be hydrated.
+    workInProgress.child = mountChildFibers(
+      workInProgress,
+      null,
+      nextChildren,
+      renderExpirationTime
+    );
+  } else {
+    // Otherwise reset hydration state in case we aborted and resumed another
+    // root.
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
+    resetHydrationState();
+  }
+  return workInProgress.child;
 }
 
-function updateHostComponent(current, workInProgress, renderExpirationTime) {
+function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
   pushHostContext(workInProgress);
 
-  if (current === null) {
+  if (current$$1 === null) {
     tryToClaimNextHydratableInstance(workInProgress);
   }
 
   var type = workInProgress.type;
-  var memoizedProps = workInProgress.memoizedProps;
   var nextProps = workInProgress.pendingProps;
-  var prevProps = current !== null ? current.memoizedProps : null;
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (memoizedProps === nextProps) {
-    var isHidden =
-      workInProgress.mode & AsyncMode &&
-      shouldDeprioritizeSubtree(type, nextProps);
-    if (isHidden) {
-      // Before bailing out, make sure we've deprioritized a hidden component.
-      workInProgress.expirationTime = Never;
-    }
-    if (!isHidden || renderExpirationTime !== Never) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
-    }
-    // If we're rendering a hidden node at hidden priority, don't bailout. The
-    // parent is complete, but the children may not be.
-  }
+  var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
 
   var nextChildren = nextProps.children;
   var isDirectTextChild = shouldSetTextContent(type, nextProps);
@@ -10105,13 +10575,13 @@ function updateHostComponent(current, workInProgress, renderExpirationTime) {
     // this in the host environment that also have access to this prop. That
     // avoids allocating another HostText fiber and traversing it.
     nextChildren = null;
-  } else if (prevProps && shouldSetTextContent(type, prevProps)) {
+  } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
     // If we're switching from a direct text child to a normal child, or to
     // empty, we need to schedule the text content to be reset.
     workInProgress.effectTag |= ContentReset;
   }
 
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
 
   // Check the host config to see if the children are offscreen/hidden.
   if (
@@ -10119,20 +10589,24 @@ function updateHostComponent(current, workInProgress, renderExpirationTime) {
     workInProgress.mode & AsyncMode &&
     shouldDeprioritizeSubtree(type, nextProps)
   ) {
-    // Down-prioritize the children.
+    // Schedule this fiber to re-render at offscreen priority. Then bailout.
     workInProgress.expirationTime = Never;
-    // Bailout and come back to this fiber later.
     workInProgress.memoizedProps = nextProps;
     return null;
   }
 
-  reconcileChildren(current, workInProgress, nextChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    nextChildren,
+    renderExpirationTime
+  );
   memoizeProps(workInProgress, nextProps);
   return workInProgress.child;
 }
 
-function updateHostText(current, workInProgress) {
-  if (current === null) {
+function updateHostText(current$$1, workInProgress) {
+  if (current$$1 === null) {
     tryToClaimNextHydratableInstance(workInProgress);
   }
   var nextProps = workInProgress.pendingProps;
@@ -10143,12 +10617,12 @@ function updateHostText(current, workInProgress) {
 }
 
 function mountIndeterminateComponent(
-  current,
+  current$$1,
   workInProgress,
   renderExpirationTime
 ) {
   invariant(
-    current === null,
+    current$$1 === null,
     "An indeterminate component should never have mounted. This error is " +
       "likely caused by a bug in React. Please file an issue."
   );
@@ -10157,14 +10631,16 @@ function mountIndeterminateComponent(
   var unmaskedContext = getUnmaskedContext(workInProgress);
   var context = getMaskedContext(workInProgress, unmaskedContext);
 
+  prepareToReadContext(workInProgress, renderExpirationTime);
+
   var value = void 0;
 
   {
     if (fn.prototype && typeof fn.prototype.render === "function") {
-      var componentName = getComponentName(workInProgress) || "Unknown";
+      var componentName = getComponentName(fn) || "Unknown";
 
       if (!didWarnAboutBadClass[componentName]) {
-        warning(
+        warningWithoutStack$1(
           false,
           "The <%s /> component appears to have a render method, but doesn't extend React.Component. " +
             "This is likely to cause errors. Change %s to extend React.Component instead.",
@@ -10179,7 +10655,7 @@ function mountIndeterminateComponent(
       ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
     }
 
-    ReactCurrentOwner.current = workInProgress;
+    ReactCurrentOwner$3.current = workInProgress;
     value = fn(props, context);
   }
   // React DevTools reads this flag.
@@ -10215,7 +10691,7 @@ function mountIndeterminateComponent(
     adoptClassInstance(workInProgress, value);
     mountClassInstance(workInProgress, renderExpirationTime);
     return finishClassComponent(
-      current,
+      current$$1,
       workInProgress,
       true,
       hasContext,
@@ -10229,7 +10705,7 @@ function mountIndeterminateComponent(
 
       if (_Component) {
         !!_Component.childContextTypes
-          ? warning(
+          ? warningWithoutStack$1(
               false,
               "%s(...): childContextTypes cannot be defined on a functional component.",
               _Component.displayName || _Component.name || "Component"
@@ -10238,7 +10714,7 @@ function mountIndeterminateComponent(
       }
       if (workInProgress.ref !== null) {
         var info = "";
-        var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName();
+        var ownerName = getCurrentFiberOwnerNameInDevOrNull();
         if (ownerName) {
           info += "\n\nCheck the render method of `" + ownerName + "`.";
         }
@@ -10250,21 +10726,20 @@ function mountIndeterminateComponent(
         }
         if (!didWarnAboutStatelessRefs[warningKey]) {
           didWarnAboutStatelessRefs[warningKey] = true;
-          warning(
+          warning$1(
             false,
             "Stateless function components cannot be given refs. " +
-              "Attempts to access this ref will fail.%s%s",
-            info,
-            ReactDebugCurrentFiber.getCurrentFiberStackAddendum()
+              "Attempts to access this ref will fail.%s",
+            info
           );
         }
       }
 
       if (typeof fn.getDerivedStateFromProps === "function") {
-        var _componentName = getComponentName(workInProgress) || "Unknown";
+        var _componentName = getComponentName(fn) || "Unknown";
 
         if (!didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName]) {
-          warning(
+          warningWithoutStack$1(
             false,
             "%s: Stateless functional components do not support getDerivedStateFromProps.",
             _componentName
@@ -10275,53 +10750,85 @@ function mountIndeterminateComponent(
         }
       }
     }
-    reconcileChildren(current, workInProgress, value);
+    reconcileChildren(current$$1, workInProgress, value, renderExpirationTime);
     memoizeProps(workInProgress, props);
     return workInProgress.child;
   }
 }
 
-function updateTimeoutComponent(current, workInProgress, renderExpirationTime) {
+function updatePlaceholderComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   if (enableSuspense) {
     var nextProps = workInProgress.pendingProps;
-    var prevProps = workInProgress.memoizedProps;
-
-    var prevDidTimeout = workInProgress.memoizedState;
 
     // Check if we already attempted to render the normal state. If we did,
     // and we timed out, render the placeholder state.
     var alreadyCaptured = (workInProgress.effectTag & DidCapture) === NoEffect;
-    var nextDidTimeout = !alreadyCaptured;
 
-    if (hasContextChanged()) {
-      // Normally we can bail out on props equality but if context has changed
-      // we don't do the bailout and we have to reuse existing props instead.
-    } else if (nextProps === prevProps && nextDidTimeout === prevDidTimeout) {
-      return bailoutOnAlreadyFinishedWork(current, workInProgress);
+    var nextDidTimeout = void 0;
+    if (current$$1 !== null && workInProgress.updateQueue !== null) {
+      // We're outside strict mode. Something inside this Placeholder boundary
+      // suspended during the last commit. Switch to the placholder.
+      workInProgress.updateQueue = null;
+      nextDidTimeout = true;
+      // If we're recovering from an error, reconcile twice: first to delete
+      // all the existing children.
+      reconcileChildren(current$$1, workInProgress, null, renderExpirationTime);
+      current$$1.child = null;
+      // Now we can continue reconciling like normal. This has the effect of
+      // remounting all children regardless of whether their their
+      // identity matches.
+    } else {
+      nextDidTimeout = !alreadyCaptured;
+    }
+
+    if ((workInProgress.mode & StrictMode) !== NoEffect) {
+      if (nextDidTimeout) {
+        // If the timed-out view commits, schedule an update effect to record
+        // the committed time.
+        workInProgress.effectTag |= Update;
+      } else {
+        // The state node points to the time at which placeholder timed out.
+        // We can clear it once we switch back to the normal children.
+        workInProgress.stateNode = null;
+      }
+    }
+
+    // If the `children` prop is a function, treat it like a render prop.
+    // TODO: This is temporary until we finalize a lower level API.
+    var children = nextProps.children;
+    var nextChildren = void 0;
+    if (typeof children === "function") {
+      nextChildren = children(nextDidTimeout);
+    } else {
+      nextChildren = nextDidTimeout ? nextProps.fallback : children;
     }
 
-    var render = nextProps.children;
-    var nextChildren = render(nextDidTimeout);
     workInProgress.memoizedProps = nextProps;
     workInProgress.memoizedState = nextDidTimeout;
-    reconcileChildren(current, workInProgress, nextChildren);
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
     return workInProgress.child;
   } else {
     return null;
   }
 }
 
-function updatePortalComponent(current, workInProgress, renderExpirationTime) {
+function updatePortalComponent(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
   var nextChildren = workInProgress.pendingProps;
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (workInProgress.memoizedProps === nextChildren) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-
-  if (current === null) {
+  if (current$$1 === null) {
     // Portals are special because we don't append the children during mount
     // but at commit. Therefore we need to track insertions which the normal
     // flow doesn't do during mount. This doesn't happen at the root because
@@ -10335,123 +10842,27 @@ function updatePortalComponent(current, workInProgress, renderExpirationTime) {
     );
     memoizeProps(workInProgress, nextChildren);
   } else {
-    reconcileChildren(current, workInProgress, nextChildren);
+    reconcileChildren(
+      current$$1,
+      workInProgress,
+      nextChildren,
+      renderExpirationTime
+    );
     memoizeProps(workInProgress, nextChildren);
   }
   return workInProgress.child;
 }
 
-function propagateContextChange(
+function updateContextProvider(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  if (fiber !== null) {
-    // Set the return pointer of the child to the work-in-progress fiber.
-    fiber.return = workInProgress;
-  }
-  while (fiber !== null) {
-    var nextFiber = void 0;
-    // Visit this fiber.
-    switch (fiber.tag) {
-      case ContextConsumer:
-        // Check if the context matches.
-        var observedBits = fiber.stateNode | 0;
-        if (fiber.type === context && (observedBits & changedBits) !== 0) {
-          // Update the expiration time of all the ancestors, including
-          // the alternates.
-          var node = fiber;
-          while (node !== null) {
-            var alternate = node.alternate;
-            if (
-              node.expirationTime === NoWork ||
-              node.expirationTime > renderExpirationTime
-            ) {
-              node.expirationTime = renderExpirationTime;
-              if (
-                alternate !== null &&
-                (alternate.expirationTime === NoWork ||
-                  alternate.expirationTime > renderExpirationTime)
-              ) {
-                alternate.expirationTime = renderExpirationTime;
-              }
-            } else if (
-              alternate !== null &&
-              (alternate.expirationTime === NoWork ||
-                alternate.expirationTime > renderExpirationTime)
-            ) {
-              alternate.expirationTime = renderExpirationTime;
-            } else {
-              // Neither alternate was updated, which means the rest of the
-              // ancestor path already has sufficient priority.
-              break;
-            }
-            node = node.return;
-          }
-          // Don't scan deeper than a matching consumer. When we render the
-          // consumer, we'll continue scanning from that point. This way the
-          // scanning work is time-sliced.
-          nextFiber = null;
-        } else {
-          // Traverse down.
-          nextFiber = fiber.child;
-        }
-        break;
-      case ContextProvider:
-        // Don't scan deeper if this is a matching provider
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        // Traverse down.
-        nextFiber = fiber.child;
-        break;
-    }
-    if (nextFiber !== null) {
-      // Set the return pointer of the child to the work-in-progress fiber.
-      nextFiber.return = fiber;
-    } else {
-      // No child. Traverse to next sibling.
-      nextFiber = fiber;
-      while (nextFiber !== null) {
-        if (nextFiber === workInProgress) {
-          // We're back to the root of this subtree. Exit.
-          nextFiber = null;
-          break;
-        }
-        var sibling = nextFiber.sibling;
-        if (sibling !== null) {
-          // Set the return pointer of the sibling to the work-in-progress fiber.
-          sibling.return = nextFiber.return;
-          nextFiber = sibling;
-          break;
-        }
-        // No more siblings. Traverse up.
-        nextFiber = nextFiber.return;
-      }
-    }
-    fiber = nextFiber;
-  }
-}
-
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
   var providerType = workInProgress.type;
   var context = providerType._context;
 
   var newProps = workInProgress.pendingProps;
   var oldProps = workInProgress.memoizedProps;
-  var canBailOnProps = true;
-
-  if (hasContextChanged()) {
-    canBailOnProps = false;
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (oldProps === newProps) {
-    workInProgress.stateNode = 0;
-    pushProvider(workInProgress);
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
 
   var newValue = newProps.value;
   workInProgress.memoizedProps = newProps;
@@ -10465,7 +10876,7 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
         newProps,
         "prop",
         "Context.Provider",
-        getCurrentFiberStackAddendum$1
+        getCurrentFiberStackInDev
       );
     }
   }
@@ -10473,14 +10884,18 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
   var changedBits = void 0;
   if (oldProps === null) {
     // Initial render
-    changedBits = MAX_SIGNED_31_BIT_INT;
+    changedBits = maxSigned31BitInt;
   } else {
     if (oldProps.value === newProps.value) {
       // No change. Bailout early if children are the same.
-      if (oldProps.children === newProps.children && canBailOnProps) {
+      if (oldProps.children === newProps.children && !hasContextChanged()) {
         workInProgress.stateNode = 0;
         pushProvider(workInProgress);
-        return bailoutOnAlreadyFinishedWork(current, workInProgress);
+        return bailoutOnAlreadyFinishedWork(
+          current$$1,
+          workInProgress,
+          renderExpirationTime
+        );
       }
       changedBits = 0;
     } else {
@@ -10494,20 +10909,24 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
         (oldValue !== oldValue && newValue !== newValue) // eslint-disable-line no-self-compare
       ) {
         // No change. Bailout early if children are the same.
-        if (oldProps.children === newProps.children && canBailOnProps) {
+        if (oldProps.children === newProps.children && !hasContextChanged()) {
           workInProgress.stateNode = 0;
           pushProvider(workInProgress);
-          return bailoutOnAlreadyFinishedWork(current, workInProgress);
+          return bailoutOnAlreadyFinishedWork(
+            current$$1,
+            workInProgress,
+            renderExpirationTime
+          );
         }
         changedBits = 0;
       } else {
         changedBits =
           typeof context._calculateChangedBits === "function"
             ? context._calculateChangedBits(oldValue, newValue)
-            : MAX_SIGNED_31_BIT_INT;
+            : maxSigned31BitInt;
         {
-          !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits)
-            ? warning(
+          !((changedBits & maxSigned31BitInt) === changedBits)
+            ? warning$1(
                 false,
                 "calculateChangedBits: Expected the return value to be a " +
                   "31-bit integer. Instead received: %s",
@@ -10519,10 +10938,14 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
 
         if (changedBits === 0) {
           // No change. Bailout early if children are the same.
-          if (oldProps.children === newProps.children && canBailOnProps) {
+          if (oldProps.children === newProps.children && !hasContextChanged()) {
             workInProgress.stateNode = 0;
             pushProvider(workInProgress);
-            return bailoutOnAlreadyFinishedWork(current, workInProgress);
+            return bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
           }
         } else {
           propagateContextChange(
@@ -10540,57 +10963,27 @@ function updateContextProvider(current, workInProgress, renderExpirationTime) {
   pushProvider(workInProgress);
 
   var newChildren = newProps.children;
-  reconcileChildren(current, workInProgress, newChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    newChildren,
+    renderExpirationTime
+  );
   return workInProgress.child;
 }
 
-function updateContextConsumer(current, workInProgress, renderExpirationTime) {
+function updateContextConsumer(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   var context = workInProgress.type;
   var newProps = workInProgress.pendingProps;
-  var oldProps = workInProgress.memoizedProps;
-
-  var newValue = getContextCurrentValue(context);
-  var changedBits = getContextChangedBits(context);
-
-  if (hasContextChanged()) {
-    // Normally we can bail out on props equality but if context has changed
-    // we don't do the bailout and we have to reuse existing props instead.
-  } else if (changedBits === 0 && oldProps === newProps) {
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  workInProgress.memoizedProps = newProps;
-
-  var observedBits = newProps.unstable_observedBits;
-  if (observedBits === undefined || observedBits === null) {
-    // Subscribe to all changes by default
-    observedBits = MAX_SIGNED_31_BIT_INT;
-  }
-  // Store the observedBits on the fiber's stateNode for quick access.
-  workInProgress.stateNode = observedBits;
-
-  if ((changedBits & observedBits) !== 0) {
-    // Context change propagation stops at matching consumers, for time-
-    // slicing. Continue the propagation here.
-    propagateContextChange(
-      workInProgress,
-      context,
-      changedBits,
-      renderExpirationTime
-    );
-  } else if (oldProps === newProps) {
-    // Skip over a memoized parent with a bitmask bailout even
-    // if we began working on it because of a deeper matching child.
-    return bailoutOnAlreadyFinishedWork(current, workInProgress);
-  }
-  // There is no bailout on `children` equality because we expect people
-  // to often pass a bound method as a child, but it may reference
-  // `this.state` or `this.props` (and thus needs to re-render on `setState`).
-
   var render = newProps.children;
 
   {
     !(typeof render === "function")
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "A context consumer was rendered with multiple children, or a child " +
             "that isn't a function. A context consumer expects a single child " +
@@ -10600,17 +10993,25 @@ function updateContextConsumer(current, workInProgress, renderExpirationTime) {
       : void 0;
   }
 
+  prepareToReadContext(workInProgress, renderExpirationTime);
+  var newValue = readContext(context, newProps.unstable_observedBits);
   var newChildren = void 0;
   {
-    ReactCurrentOwner.current = workInProgress;
-    ReactDebugCurrentFiber.setCurrentPhase("render");
+    ReactCurrentOwner$3.current = workInProgress;
+    setCurrentPhase("render");
     newChildren = render(newValue);
-    ReactDebugCurrentFiber.setCurrentPhase(null);
+    setCurrentPhase(null);
   }
 
   // React DevTools reads this flag.
   workInProgress.effectTag |= PerformedWork;
-  reconcileChildren(current, workInProgress, newChildren);
+  reconcileChildren(
+    current$$1,
+    workInProgress,
+    newChildren,
+    renderExpirationTime
+  );
+  workInProgress.memoizedProps = newProps;
   return workInProgress.child;
 }
 
@@ -10633,59 +11034,39 @@ function updateContextConsumer(current, workInProgress, renderExpirationTime) {
   }
   */
 
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
+  workInProgress,
+  renderExpirationTime
+) {
   cancelWorkTimer(workInProgress);
 
+  if (current$$1 !== null) {
+    // Reuse previous context list
+    workInProgress.firstContextDependency = current$$1.firstContextDependency;
+  }
+
   if (enableProfilerTimer) {
     // Don't update "base" render times for bailouts.
     stopBaseRenderTimerIfRunning();
   }
 
-  // TODO: We should ideally be able to bail out early if the children have no
-  // more work to do. However, since we don't have a separation of this
-  // Fiber's priority and its children yet - we don't know without doing lots
-  // of the same work we do anyway. Once we have that separation we can just
-  // bail out here if the children has no more work at this priority level.
-  // if (workInProgress.priorityOfChildren <= priorityLevel) {
-  //   // If there are side-effects in these children that have not yet been
-  //   // committed we need to ensure that they get properly transferred up.
-  //   if (current && current.child !== workInProgress.child) {
-  //     reuseChildrenEffects(workInProgress, child);
-  //   }
-  //   return null;
-  // }
-
-  cloneChildFibers(current, workInProgress);
-  return workInProgress.child;
-}
-
-function bailoutOnLowPriority(current, workInProgress) {
-  cancelWorkTimer(workInProgress);
-
-  if (enableProfilerTimer) {
-    // Don't update "base" render times for bailouts.
-    stopBaseRenderTimerIfRunning();
+  // Check if the children have any pending work.
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (
+    childExpirationTime === NoWork ||
+    childExpirationTime > renderExpirationTime
+  ) {
+    // The children don't have any work either. We can skip them.
+    // TODO: Once we add back resuming, we should check if the children are
+    // a work-in-progress set. If so, we need to transfer their effects.
+    return null;
+  } else {
+    // This fiber doesn't have work, but its subtree does. Clone the child
+    // fibers and continue.
+    cloneChildFibers(current$$1, workInProgress);
+    return workInProgress.child;
   }
-
-  // TODO: Handle HostComponent tags here as well and call pushHostContext()?
-  // See PR 8590 discussion for context
-  switch (workInProgress.tag) {
-    case HostRoot:
-      pushHostRootContext(workInProgress);
-      break;
-    case ClassComponent:
-      pushContextProvider(workInProgress);
-      break;
-    case HostPortal:
-      pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
-      break;
-    case ContextProvider:
-      pushProvider(workInProgress);
-      break;
-  }
-  // TODO: What if this is currently in progress?
-  // How can that happen? How is this not being cloned?
-  return null;
 }
 
 // TODO: Delete memoizeProps/State and move to reconcile/bailout instead
@@ -10699,70 +11080,117 @@ function memoizeState(workInProgress, nextState) {
   // is handled by processUpdateQueue.
 }
 
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
   if (enableProfilerTimer) {
     if (workInProgress.mode & ProfileMode) {
       markActualRenderTimeStarted(workInProgress);
     }
   }
 
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    workInProgress.expirationTime === NoWork ||
-    workInProgress.expirationTime > renderExpirationTime
+    !hasContextChanged() &&
+    (updateExpirationTime === NoWork ||
+      updateExpirationTime > renderExpirationTime)
   ) {
-    return bailoutOnLowPriority(current, workInProgress);
+    // This fiber does not have any pending work. Bailout without entering
+    // the begin phase. There's still some bookkeeping we that needs to be done
+    // in this optimized path, mostly pushing stuff onto the stack.
+    switch (workInProgress.tag) {
+      case HostRoot:
+        pushHostRootContext(workInProgress);
+        resetHydrationState();
+        break;
+      case HostComponent:
+        pushHostContext(workInProgress);
+        break;
+      case ClassComponent:
+        pushContextProvider(workInProgress);
+        break;
+      case HostPortal:
+        pushHostContainer(
+          workInProgress,
+          workInProgress.stateNode.containerInfo
+        );
+        break;
+      case ContextProvider:
+        workInProgress.stateNode = 0;
+        pushProvider(workInProgress);
+        break;
+      case Profiler:
+        if (enableProfilerTimer) {
+          workInProgress.effectTag |= Update;
+        }
+        break;
+    }
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
 
+  // Before entering the begin phase, clear the expiration time.
+  workInProgress.expirationTime = NoWork;
+
   switch (workInProgress.tag) {
     case IndeterminateComponent:
       return mountIndeterminateComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case FunctionalComponent:
-      return updateFunctionalComponent(current, workInProgress);
+      return updateFunctionalComponent(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     case ClassComponent:
       return updateClassComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case HostRoot:
-      return updateHostRoot(current, workInProgress, renderExpirationTime);
+      return updateHostRoot(current$$1, workInProgress, renderExpirationTime);
     case HostComponent:
-      return updateHostComponent(current, workInProgress, renderExpirationTime);
+      return updateHostComponent(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      );
     case HostText:
-      return updateHostText(current, workInProgress);
-    case TimeoutComponent:
-      return updateTimeoutComponent(
-        current,
+      return updateHostText(current$$1, workInProgress);
+    case PlaceholderComponent:
+      return updatePlaceholderComponent(
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case HostPortal:
       return updatePortalComponent(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case ForwardRef:
-      return updateForwardRef(current, workInProgress);
+      return updateForwardRef(current$$1, workInProgress, renderExpirationTime);
     case Fragment:
-      return updateFragment(current, workInProgress);
+      return updateFragment(current$$1, workInProgress, renderExpirationTime);
     case Mode:
-      return updateMode(current, workInProgress);
+      return updateMode(current$$1, workInProgress, renderExpirationTime);
     case Profiler:
-      return updateProfiler(current, workInProgress);
+      return updateProfiler(current$$1, workInProgress, renderExpirationTime);
     case ContextProvider:
       return updateContextProvider(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
     case ContextConsumer:
       return updateContextConsumer(
-        current,
+        current$$1,
         workInProgress,
         renderExpirationTime
       );
@@ -10994,19 +11422,13 @@ if (supportsMutation) {
 function completeWork(current, workInProgress, renderExpirationTime) {
   var newProps = workInProgress.pendingProps;
 
-  if (enableProfilerTimer) {
-    if (workInProgress.mode & ProfileMode) {
-      recordElapsedActualRenderTime(workInProgress);
-    }
-  }
-
   switch (workInProgress.tag) {
     case FunctionalComponent:
-      return null;
+      break;
     case ClassComponent: {
       // We are leaving this subtree, so pop context if any.
       popContextProvider(workInProgress);
-      return null;
+      break;
     }
     case HostRoot: {
       popHostContainer(workInProgress);
@@ -11025,7 +11447,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
         workInProgress.effectTag &= ~Placement;
       }
       updateHostContainer(workInProgress);
-      return null;
+      break;
     }
     case HostComponent: {
       popHostContext(workInProgress);
@@ -11075,7 +11497,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
               "caused by a bug in React. Please file an issue."
           );
           // This can happen when we abort work.
-          return null;
+          break;
         }
 
         var _currentHostContext = getHostContext();
@@ -11131,7 +11553,7 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           markRef$1(workInProgress);
         }
       }
-      return null;
+      break;
     }
     case HostText: {
       var newText = newProps;
@@ -11148,7 +11570,6 @@ function completeWork(current, workInProgress, renderExpirationTime) {
               "caused by a bug in React. Please file an issue."
           );
           // This can happen when we abort work.
-          return null;
         }
         var _rootContainerInstance = getRootHostContainer();
         var _currentHostContext2 = getHostContext();
@@ -11166,28 +11587,28 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           );
         }
       }
-      return null;
+      break;
     }
     case ForwardRef:
-      return null;
-    case TimeoutComponent:
-      return null;
+      break;
+    case PlaceholderComponent:
+      break;
     case Fragment:
-      return null;
+      break;
     case Mode:
-      return null;
+      break;
     case Profiler:
-      return null;
+      break;
     case HostPortal:
       popHostContainer(workInProgress);
       updateHostContainer(workInProgress);
-      return null;
+      break;
     case ContextProvider:
       // Pop provider fiber
       popProvider(workInProgress);
-      return null;
+      break;
     case ContextConsumer:
-      return null;
+      break;
     // Error cases
     case IndeterminateComponent:
       invariant(
@@ -11204,6 +11625,18 @@ function completeWork(current, workInProgress, renderExpirationTime) {
           "React. Please file an issue."
       );
   }
+
+  if (enableProfilerTimer) {
+    if (workInProgress.mode & ProfileMode) {
+      // Don't record elapsed time unless the "complete" phase has succeeded.
+      // Certain renderers may error during this phase (i.e. ReactNative View/Text nesting validation).
+      // If an error occurs, we'll mark the time while unwinding.
+      // This simplifies the unwinding logic and ensures consistency.
+      recordElapsedActualRenderTime(workInProgress);
+    }
+  }
+
+  return null;
 }
 
 // Module provided by RN:
@@ -11311,6 +11744,8 @@ var invokeGuardedCallback$3 = ReactErrorUtils.invokeGuardedCallback;
 var hasCaughtError$1 = ReactErrorUtils.hasCaughtError;
 var clearCaughtError$1 = ReactErrorUtils.clearCaughtError;
 
+var emptyObject$1 = {};
+
 var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
 {
   didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
@@ -11320,11 +11755,11 @@ function logError(boundary, errorInfo) {
   var source = errorInfo.source;
   var stack = errorInfo.stack;
   if (stack === null && source !== null) {
-    stack = getStackAddendumByWorkInProgressFiber(source);
+    stack = getStackByFiberInDevAndProd(source);
   }
 
   var capturedError = {
-    componentName: source !== null ? getComponentName(source) : null,
+    componentName: source !== null ? getComponentName(source.type) : null,
     componentStack: stack !== null ? stack : "",
     error: errorInfo.value,
     errorBoundary: null,
@@ -11335,7 +11770,7 @@ function logError(boundary, errorInfo) {
 
   if (boundary !== null && boundary.tag === ClassComponent) {
     capturedError.errorBoundary = boundary.stateNode;
-    capturedError.errorBoundaryName = getComponentName(boundary);
+    capturedError.errorBoundaryName = getComponentName(boundary.type);
     capturedError.errorBoundaryFound = true;
     capturedError.willRetry = true;
   }
@@ -11352,40 +11787,40 @@ function logError(boundary, errorInfo) {
   }
 }
 
-var callComponentWillUnmountWithTimer = function(current, instance) {
-  startPhaseTimer(current, "componentWillUnmount");
-  instance.props = current.memoizedProps;
-  instance.state = current.memoizedState;
+var callComponentWillUnmountWithTimer = function(current$$1, instance) {
+  startPhaseTimer(current$$1, "componentWillUnmount");
+  instance.props = current$$1.memoizedProps;
+  instance.state = current$$1.memoizedState;
   instance.componentWillUnmount();
   stopPhaseTimer();
 };
 
 // Capture errors so they don't interrupt unmounting.
-function safelyCallComponentWillUnmount(current, instance) {
+function safelyCallComponentWillUnmount(current$$1, instance) {
   {
     invokeGuardedCallback$3(
       null,
       callComponentWillUnmountWithTimer,
       null,
-      current,
+      current$$1,
       instance
     );
     if (hasCaughtError$1()) {
       var unmountError = clearCaughtError$1();
-      captureCommitPhaseError(current, unmountError);
+      captureCommitPhaseError(current$$1, unmountError);
     }
   }
 }
 
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (ref !== null) {
     if (typeof ref === "function") {
       {
         invokeGuardedCallback$3(null, ref, null, null);
         if (hasCaughtError$1()) {
           var refError = clearCaughtError$1();
-          captureCommitPhaseError(current, refError);
+          captureCommitPhaseError(current$$1, refError);
         }
       }
     } else {
@@ -11394,13 +11829,13 @@ function safelyDetachRef(current) {
   }
 }
 
-function commitBeforeMutationLifeCycles(current, finishedWork) {
+function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case ClassComponent: {
       if (finishedWork.effectTag & Snapshot) {
-        if (current !== null) {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
+        if (current$$1 !== null) {
+          var prevProps = current$$1.memoizedProps;
+          var prevState = current$$1.memoizedState;
           startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
           var instance = finishedWork.stateNode;
           instance.props = finishedWork.memoizedProps;
@@ -11410,11 +11845,11 @@ function commitBeforeMutationLifeCycles(current, finishedWork) {
             var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;
             if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
               didWarnSet.add(finishedWork.type);
-              warning(
+              warningWithoutStack$1(
                 false,
                 "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " +
                   "must be returned. You have returned undefined.",
-                getComponentName(finishedWork)
+                getComponentName(finishedWork.type)
               );
             }
           }
@@ -11442,24 +11877,23 @@ function commitBeforeMutationLifeCycles(current, finishedWork) {
 
 function commitLifeCycles(
   finishedRoot,
-  current,
+  current$$1,
   finishedWork,
-  currentTime,
   committedExpirationTime
 ) {
   switch (finishedWork.tag) {
     case ClassComponent: {
       var instance = finishedWork.stateNode;
       if (finishedWork.effectTag & Update) {
-        if (current === null) {
+        if (current$$1 === null) {
           startPhaseTimer(finishedWork, "componentDidMount");
           instance.props = finishedWork.memoizedProps;
           instance.state = finishedWork.memoizedState;
           instance.componentDidMount();
           stopPhaseTimer();
         } else {
-          var prevProps = current.memoizedProps;
-          var prevState = current.memoizedState;
+          var prevProps = current$$1.memoizedProps;
+          var prevState = current$$1.memoizedState;
           startPhaseTimer(finishedWork, "componentDidUpdate");
           instance.props = finishedWork.memoizedProps;
           instance.state = finishedWork.memoizedState;
@@ -11514,7 +11948,7 @@ function commitLifeCycles(
       // (eg DOM renderer may schedule auto-focus for inputs and form controls).
       // These effects should only be committed when components are first mounted,
       // aka when there is no current/alternate.
-      if (current === null && finishedWork.effectTag & Update) {
+      if (current$$1 === null && finishedWork.effectTag & Update) {
         var type = finishedWork.type;
         var props = finishedWork.memoizedProps;
       }
@@ -11533,8 +11967,23 @@ function commitLifeCycles(
       // We have no life-cycles associated with Profiler.
       return;
     }
-    case TimeoutComponent: {
-      // We have no life-cycles associated with Timeouts.
+    case PlaceholderComponent: {
+      if (enableSuspense) {
+        if ((finishedWork.mode & StrictMode) === NoEffect) {
+          // In loose mode, a placeholder times out by scheduling a synchronous
+          // update in the commit phase. Use `updateQueue` field to signal that
+          // the Timeout needs to switch to the placeholder. We don't need an
+          // entire queue. Any non-null value works.
+          // $FlowFixMe - Intentionally using a value other than an UpdateQueue.
+          finishedWork.updateQueue = emptyObject$1;
+          scheduleWork(finishedWork, Sync);
+        } else {
+          // In strict mode, the Update effect is used to record the time at
+          // which the placeholder timed out.
+          var currentTime = requestCurrentTime();
+          finishedWork.stateNode = { timedOutAt: currentTime };
+        }
+      }
       return;
     }
     default: {
@@ -11564,12 +12013,12 @@ function commitAttachRef(finishedWork) {
     } else {
       {
         if (!ref.hasOwnProperty("current")) {
-          warning(
+          warningWithoutStack$1(
             false,
             "Unexpected ref object provided for %s. " +
               "Use either a ref-setter function or React.createRef().%s",
-            getComponentName(finishedWork),
-            getStackAddendumByWorkInProgressFiber(finishedWork)
+            getComponentName(finishedWork.type),
+            getStackByFiberInDevAndProd(finishedWork)
           );
         }
       }
@@ -11579,8 +12028,8 @@ function commitAttachRef(finishedWork) {
   }
 }
 
-function commitDetachRef(current) {
-  var currentRef = current.ref;
+function commitDetachRef(current$$1) {
+  var currentRef = current$$1.ref;
   if (currentRef !== null) {
     if (typeof currentRef === "function") {
       currentRef(null);
@@ -11593,22 +12042,20 @@ function commitDetachRef(current) {
 // User-originating errors (lifecycles and refs) should not interrupt
 // deletion, so don't let them throw. Host-originating errors should
 // interrupt deletion, so it's okay
-function commitUnmount(current) {
-  if (typeof onCommitUnmount === "function") {
-    onCommitUnmount(current);
-  }
+function commitUnmount(current$$1) {
+  onCommitUnmount(current$$1);
 
-  switch (current.tag) {
+  switch (current$$1.tag) {
     case ClassComponent: {
-      safelyDetachRef(current);
-      var instance = current.stateNode;
+      safelyDetachRef(current$$1);
+      var instance = current$$1.stateNode;
       if (typeof instance.componentWillUnmount === "function") {
-        safelyCallComponentWillUnmount(current, instance);
+        safelyCallComponentWillUnmount(current$$1, instance);
       }
       return;
     }
     case HostComponent: {
-      safelyDetachRef(current);
+      safelyDetachRef(current$$1);
       return;
     }
     case HostPortal: {
@@ -11616,9 +12063,9 @@ function commitUnmount(current) {
       // We are also not using this parent because
       // the portal will get pushed immediately.
       if (supportsMutation) {
-        unmountHostComponents(current);
+        unmountHostComponents(current$$1);
       } else if (supportsPersistence) {
-        emptyPortalContainer(current);
+        emptyPortalContainer(current$$1);
       }
       return;
     }
@@ -11659,26 +12106,26 @@ function commitNestedUnmounts(root) {
   }
 }
 
-function detachFiber(current) {
+function detachFiber(current$$1) {
   // Cut off the return pointers to disconnect it from the tree. Ideally, we
   // should clear the child pointer of the parent alternate to let this
   // get GC:ed but we don't know which for sure which parent is the current
   // one so we'll settle for GC:ing the subtree of this child. This child
   // itself will be GC:ed when the parent updates the next time.
-  current.return = null;
-  current.child = null;
-  if (current.alternate) {
-    current.alternate.child = null;
-    current.alternate.return = null;
+  current$$1.return = null;
+  current$$1.child = null;
+  if (current$$1.alternate) {
+    current$$1.alternate.child = null;
+    current$$1.alternate.return = null;
   }
 }
 
-function emptyPortalContainer(current) {
+function emptyPortalContainer(current$$1) {
   if (!supportsPersistence) {
     return;
   }
 
-  var portal = current.stateNode;
+  var portal = current$$1.stateNode;
   var containerInfo = portal.containerInfo;
 
   var emptyChildSet = createContainerChildSet(containerInfo);
@@ -11790,8 +12237,11 @@ function commitPlacement(finishedWork) {
 
   // Recursively insert all host nodes into the parent.
   var parentFiber = getHostParentFiber(finishedWork);
+
+  // Note: these two variables *must* always be updated together.
   var parent = void 0;
   var isContainer = void 0;
+
   switch (parentFiber.tag) {
     case HostComponent:
       parent = parentFiber.stateNode;
@@ -11859,13 +12309,15 @@ function commitPlacement(finishedWork) {
   }
 }
 
-function unmountHostComponents(current) {
-  // We only have the top Fiber that was inserted but we need recurse down its
-  var node = current;
+function unmountHostComponents(current$$1) {
+  // We only have the top Fiber that was deleted but we need recurse down its
+  var node = current$$1;
 
   // Each iteration, currentParent is populated with node's host parent if not
   // currentParentIsValid.
   var currentParentIsValid = false;
+
+  // Note: these two variables *must* always be updated together.
   var currentParent = void 0;
   var currentParentIsContainer = void 0;
 
@@ -11911,6 +12363,7 @@ function unmountHostComponents(current) {
       // When we go into a portal, it becomes the parent to remove from.
       // We will reassign it back when we pop the portal on the way up.
       currentParent = node.stateNode.containerInfo;
+      currentParentIsContainer = true;
       // Visit children because portals might contain host components.
       if (node.child !== null) {
         node.child.return = node;
@@ -11926,11 +12379,11 @@ function unmountHostComponents(current) {
         continue;
       }
     }
-    if (node === current) {
+    if (node === current$$1) {
       return;
     }
     while (node.sibling === null) {
-      if (node.return === null || node.return === current) {
+      if (node.return === null || node.return === current$$1) {
         return;
       }
       node = node.return;
@@ -11945,19 +12398,19 @@ function unmountHostComponents(current) {
   }
 }
 
-function commitDeletion(current) {
+function commitDeletion(current$$1) {
   if (supportsMutation) {
     // Recursively delete all host nodes from the parent.
     // Detach refs and call componentWillUnmount() on the whole subtree.
-    unmountHostComponents(current);
+    unmountHostComponents(current$$1);
   } else {
     // Detach refs and call componentWillUnmount() on the whole subtree.
-    commitNestedUnmounts(current);
+    commitNestedUnmounts(current$$1);
   }
-  detachFiber(current);
+  detachFiber(current$$1);
 }
 
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   if (!supportsMutation) {
     commitContainer(finishedWork);
     return;
@@ -11975,7 +12428,8 @@ function commitWork(current, finishedWork) {
         // For hydration we reuse the update path but we treat the oldProps
         // as the newProps. The updatePayload will contain the real change in
         // this case.
-        var oldProps = current !== null ? current.memoizedProps : newProps;
+        var oldProps =
+          current$$1 !== null ? current$$1.memoizedProps : newProps;
         var type = finishedWork.type;
         // TODO: Type the updateQueue to be specific to host components.
         var updatePayload = finishedWork.updateQueue;
@@ -12004,7 +12458,7 @@ function commitWork(current, finishedWork) {
       // For hydration we reuse the update path but we treat the oldProps
       // as the newProps. The updatePayload will contain the real change in
       // this case.
-      var oldText = current !== null ? current.memoizedProps : newText;
+      var oldText = current$$1 !== null ? current$$1.memoizedProps : newText;
       commitTextUpdate(textInstance, oldText, newText);
       return;
     }
@@ -12016,16 +12470,16 @@ function commitWork(current, finishedWork) {
         var onRender = finishedWork.memoizedProps.onRender;
         onRender(
           finishedWork.memoizedProps.id,
-          current === null ? "mount" : "update",
+          current$$1 === null ? "mount" : "update",
           finishedWork.actualDuration,
-          finishedWork.treeBaseTime,
+          finishedWork.treeBaseDuration,
           finishedWork.actualStartTime,
           getCommitTime()
         );
       }
       return;
     }
-    case TimeoutComponent: {
+    case PlaceholderComponent: {
       return;
     }
     default: {
@@ -12038,11 +12492,15 @@ function commitWork(current, finishedWork) {
   }
 }
 
-function commitResetTextContent(current) {
+function commitResetTextContent(current$$1) {
   if (!supportsMutation) {
     return;
   }
-  resetTextContent(current.stateNode);
+  resetTextContent(current$$1.stateNode);
+}
+
+function NoopComponent() {
+  return null;
 }
 
 function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
@@ -12099,23 +12557,12 @@ function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
   return update;
 }
 
-function schedulePing(finishedWork) {
-  // Once the promise resolves, we should try rendering the non-
-  // placeholder state again.
-  var currentTime = recalculateCurrentTime();
-  var expirationTime = computeExpirationForFiber(currentTime, finishedWork);
-  var recoveryUpdate = createUpdate(expirationTime);
-  enqueueUpdate(finishedWork, recoveryUpdate, expirationTime);
-  scheduleWork(finishedWork, expirationTime);
-}
-
 function throwException(
   root,
   returnFiber,
   sourceFiber,
   value,
-  renderExpirationTime,
-  currentTimeMs
+  renderExpirationTime
 ) {
   // The source fiber did not complete.
   sourceFiber.effectTag |= Incomplete;
@@ -12131,111 +12578,175 @@ function throwException(
     // This is a thenable.
     var thenable = value;
 
-    // TODO: Should use the earliest known expiration time
-    var expirationTimeMs = expirationTimeToMs(renderExpirationTime);
-    var startTimeMs = expirationTimeMs - 5000;
-    var elapsedMs = currentTimeMs - startTimeMs;
-    if (elapsedMs < 0) {
-      elapsedMs = 0;
-    }
-    var remainingTimeMs = expirationTimeMs - currentTimeMs;
-
-    // Find the earliest timeout of all the timeouts in the ancestor path.
-    // TODO: Alternatively, we could store the earliest timeout on the context
-    // stack, rather than searching on every suspend.
+    // Find the earliest timeout threshold of all the placeholders in the
+    // ancestor path. We could avoid this traversal by storing the thresholds on
+    // the stack, but we choose not to because we only hit this path if we're
+    // IO-bound (i.e. if something suspends). Whereas the stack is used even in
+    // the non-IO- bound case.
     var _workInProgress = returnFiber;
     var earliestTimeoutMs = -1;
-    searchForEarliestTimeout: do {
-      if (_workInProgress.tag === TimeoutComponent) {
+    var startTimeMs = -1;
+    do {
+      if (_workInProgress.tag === PlaceholderComponent) {
         var current = _workInProgress.alternate;
-        if (current !== null && current.memoizedState === true) {
-          // A parent Timeout already committed in a placeholder state. We
-          // need to handle this promise immediately. In other words, we
-          // should never suspend inside a tree that already expired.
-          earliestTimeoutMs = 0;
-          break searchForEarliestTimeout;
+        if (
+          current !== null &&
+          current.memoizedState === true &&
+          current.stateNode !== null
+        ) {
+          // Reached a placeholder that already timed out. Each timed out
+          // placeholder acts as the root of a new suspense boundary.
+
+          // Use the time at which the placeholder timed out as the start time
+          // for the current render.
+          var timedOutAt = current.stateNode.timedOutAt;
+          startTimeMs = expirationTimeToMs(timedOutAt);
+
+          // Do not search any further.
+          break;
         }
-        var timeoutPropMs = _workInProgress.pendingProps.ms;
+        var timeoutPropMs = _workInProgress.pendingProps.delayMs;
         if (typeof timeoutPropMs === "number") {
           if (timeoutPropMs <= 0) {
             earliestTimeoutMs = 0;
-            break searchForEarliestTimeout;
           } else if (
             earliestTimeoutMs === -1 ||
             timeoutPropMs < earliestTimeoutMs
           ) {
             earliestTimeoutMs = timeoutPropMs;
           }
-        } else if (earliestTimeoutMs === -1) {
-          earliestTimeoutMs = remainingTimeMs;
         }
       }
       _workInProgress = _workInProgress.return;
     } while (_workInProgress !== null);
 
-    // Compute the remaining time until the timeout.
-    var msUntilTimeout = earliestTimeoutMs - elapsedMs;
+    // Schedule the nearest Placeholder to re-render the timed out view.
+    _workInProgress = returnFiber;
+    do {
+      if (_workInProgress.tag === PlaceholderComponent) {
+        var didTimeout = _workInProgress.memoizedState;
+        if (!didTimeout) {
+          // Found the nearest boundary.
 
-    if (renderExpirationTime === Never || msUntilTimeout > 0) {
-      // There's still time remaining.
-      markTimeout(root, thenable, msUntilTimeout, renderExpirationTime);
-      var onResolveOrReject = function() {
-        retrySuspendedRoot(root, renderExpirationTime);
-      };
-      thenable.then(onResolveOrReject, onResolveOrReject);
-      return;
-    } else {
-      // No time remaining. Need to fallback to placeholder.
-      // Find the nearest timeout that can be retried.
-      _workInProgress = returnFiber;
-      do {
-        switch (_workInProgress.tag) {
-          case HostRoot: {
-            // The root expired, but no fallback was provided. Throw a
-            // helpful error.
-            var message =
-              renderExpirationTime === Sync
-                ? "A synchronous update was suspended, but no fallback UI " +
-                  "was provided."
-                : "An update was suspended for longer than the timeout, " +
-                  "but no fallback UI was provided.";
-            value = new Error(message);
-            break;
-          }
-          case TimeoutComponent: {
-            if ((_workInProgress.effectTag & DidCapture) === NoEffect) {
-              _workInProgress.effectTag |= ShouldCapture;
-              var _onResolveOrReject = schedulePing.bind(null, _workInProgress);
-              thenable.then(_onResolveOrReject, _onResolveOrReject);
-              return;
+          // If the boundary is not in async mode, we should not suspend, and
+          // likewise, when the promise resolves, we should ping synchronously.
+          var pingTime =
+            (_workInProgress.mode & AsyncMode) === NoEffect
+              ? Sync
+              : renderExpirationTime;
+
+          // Attach a listener to the promise to "ping" the root and retry.
+          var onResolveOrReject = retrySuspendedRoot.bind(
+            null,
+            root,
+            _workInProgress,
+            pingTime
+          );
+          thenable.then(onResolveOrReject, onResolveOrReject);
+
+          // If the boundary is outside of strict mode, we should *not* suspend
+          // the commit. Pretend as if the suspended component rendered null and
+          // keep rendering. In the commit phase, we'll schedule a subsequent
+          // synchronous update to re-render the Placeholder.
+          //
+          // Note: It doesn't matter whether the component that suspended was
+          // inside a strict mode tree. If the Placeholder is outside of it, we
+          // should *not* suspend the commit.
+          if ((_workInProgress.mode & StrictMode) === NoEffect) {
+            _workInProgress.effectTag |= Update;
+
+            // Unmount the source fiber's children
+            var nextChildren = null;
+            reconcileChildren(
+              sourceFiber.alternate,
+              sourceFiber,
+              nextChildren,
+              renderExpirationTime
+            );
+            sourceFiber.effectTag &= ~Incomplete;
+            if (sourceFiber.tag === IndeterminateComponent) {
+              // Let's just assume it's a functional component. This fiber will
+              // be unmounted in the immediate next commit, anyway.
+              sourceFiber.tag = FunctionalComponent;
             }
-            // Already captured during this render. Continue to the next
-            // Timeout ancestor.
-            break;
+
+            if (sourceFiber.tag === ClassComponent) {
+              // We're going to commit this fiber even though it didn't
+              // complete. But we shouldn't call any lifecycle methods or
+              // callbacks. Remove all lifecycle effect tags.
+              sourceFiber.effectTag &= ~LifecycleEffectMask;
+              if (sourceFiber.alternate === null) {
+                // We're about to mount a class component that doesn't have an
+                // instance. Turn this into a dummy functional component instead,
+                // to prevent type errors. This is a bit weird but it's an edge
+                // case and we're about to synchronously delete this
+                // component, anyway.
+                sourceFiber.tag = FunctionalComponent;
+                sourceFiber.type = NoopComponent;
+              }
+            }
+
+            // Exit without suspending.
+            return;
           }
+
+          // Confirmed that the boundary is in a strict mode tree. Continue with
+          // the normal suspend path.
+
+          var absoluteTimeoutMs = void 0;
+          if (earliestTimeoutMs === -1) {
+            // If no explicit threshold is given, default to an abitrarily large
+            // value. The actual size doesn't matter because the threshold for the
+            // whole tree will be clamped to the expiration time.
+            absoluteTimeoutMs = maxSigned31BitInt;
+          } else {
+            if (startTimeMs === -1) {
+              // This suspend happened outside of any already timed-out
+              // placeholders. We don't know exactly when the update was scheduled,
+              // but we can infer an approximate start time from the expiration
+              // time. First, find the earliest uncommitted expiration time in the
+              // tree, including work that is suspended. Then subtract the offset
+              // used to compute an async update's expiration time. This will cause
+              // high priority (interactive) work to expire earlier than neccessary,
+              // but we can account for this by adjusting for the Just Noticable
+              // Difference.
+              var earliestExpirationTime = findEarliestOutstandingPriorityLevel(
+                root,
+                renderExpirationTime
+              );
+              var earliestExpirationTimeMs = expirationTimeToMs(
+                earliestExpirationTime
+              );
+              startTimeMs = earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
+            }
+            absoluteTimeoutMs = startTimeMs + earliestTimeoutMs;
+          }
+
+          // Mark the earliest timeout in the suspended fiber's ancestor path.
+          // After completing the root, we'll take the largest of all the
+          // suspended fiber's timeouts and use it to compute a timeout for the
+          // whole tree.
+          renderDidSuspend(root, absoluteTimeoutMs, renderExpirationTime);
+
+          _workInProgress.effectTag |= ShouldCapture;
+          _workInProgress.expirationTime = renderExpirationTime;
+          return;
         }
-        _workInProgress = _workInProgress.return;
-      } while (_workInProgress !== null);
-    }
-  } else {
-    // This is an error.
-    markError(root);
-    if (
-      // Retry (at the same priority) one more time before handling the error.
-      // The retry will flush synchronously. (Unless we're already rendering
-      // synchronously, in which case move to the next check.)
-      (!root.didError && renderExpirationTime !== Sync) ||
-      // There's lower priority work. If so, it may have the effect of fixing
-      // the exception that was just thrown.
-      hasLowerPriorityWork(root, renderExpirationTime)
-    ) {
-      return;
-    }
+        // This boundary already captured during this render. Continue to the
+        // next boundary.
+      }
+      _workInProgress = _workInProgress.return;
+    } while (_workInProgress !== null);
+    // No boundary was found. Fallthrough to error mode.
+    value = new Error(
+      "An update was suspended, but no placeholder UI was provided."
+    );
   }
 
   // We didn't find a boundary that could handle this type of exception. Start
   // over and traverse parent path again, this time treating the exception
   // as an error.
+  renderDidError();
   value = createCapturedValue(value, sourceFiber);
   var workInProgress = returnFiber;
   do {
@@ -12243,12 +12754,13 @@ function throwException(
       case HostRoot: {
         var _errorInfo = value;
         workInProgress.effectTag |= ShouldCapture;
+        workInProgress.expirationTime = renderExpirationTime;
         var update = createRootErrorUpdate(
           workInProgress,
           _errorInfo,
           renderExpirationTime
         );
-        enqueueCapturedUpdate(workInProgress, update, renderExpirationTime);
+        enqueueCapturedUpdate(workInProgress, update);
         return;
       }
       case ClassComponent:
@@ -12265,13 +12777,14 @@ function throwException(
               !isAlreadyFailedLegacyErrorBoundary(instance)))
         ) {
           workInProgress.effectTag |= ShouldCapture;
+          workInProgress.expirationTime = renderExpirationTime;
           // Schedule the error boundary to re-render using updated state
           var _update = createClassErrorUpdate(
             workInProgress,
             errorInfo,
             renderExpirationTime
           );
-          enqueueCapturedUpdate(workInProgress, _update, renderExpirationTime);
+          enqueueCapturedUpdate(workInProgress, _update);
           return;
         }
         break;
@@ -12303,17 +12816,19 @@ function unwindWork(workInProgress, renderExpirationTime) {
       popHostContainer(workInProgress);
       popTopLevelContextObject(workInProgress);
       var _effectTag = workInProgress.effectTag;
-      if (_effectTag & ShouldCapture) {
-        workInProgress.effectTag = (_effectTag & ~ShouldCapture) | DidCapture;
-        return workInProgress;
-      }
-      return null;
+      invariant(
+        (_effectTag & DidCapture) === NoEffect,
+        "The root failed to unmount after an error. This is likely a bug in " +
+          "React. Please file an issue."
+      );
+      workInProgress.effectTag = (_effectTag & ~ShouldCapture) | DidCapture;
+      return workInProgress;
     }
     case HostComponent: {
       popHostContext(workInProgress);
       return null;
     }
-    case TimeoutComponent: {
+    case PlaceholderComponent: {
       var _effectTag2 = workInProgress.effectTag;
       if (_effectTag2 & ShouldCapture) {
         workInProgress.effectTag = (_effectTag2 & ~ShouldCapture) | DidCapture;
@@ -12335,8 +12850,6 @@ function unwindWork(workInProgress, renderExpirationTime) {
 function unwindInterruptedWork(interruptedWork) {
   if (enableProfilerTimer) {
     if (interruptedWork.mode & ProfileMode) {
-      // Resume in case we're picking up on work that was paused.
-      resumeActualRenderTimerIfPaused();
       recordElapsedActualRenderTime(interruptedWork);
     }
   }
@@ -12366,6 +12879,11 @@ function unwindInterruptedWork(interruptedWork) {
   }
 }
 
+var Dispatcher = {
+  readContext: readContext
+};
+
+var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
 var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback;
 var hasCaughtError = ReactErrorUtils.hasCaughtError;
 var clearCaughtError = ReactErrorUtils.clearCaughtError;
@@ -12383,28 +12901,28 @@ var warnAboutInvalidUpdates = void 0;
   warnAboutUpdateOnUnmounted = function(fiber) {
     // We show the whole stack but dedupe on the top component's name because
     // the problematic code almost always lies inside that component.
-    var componentName = getComponentName(fiber) || "ReactClass";
+    var componentName = getComponentName(fiber.type) || "ReactClass";
     if (didWarnStateUpdateForUnmountedComponent[componentName]) {
       return;
     }
-    warning(
+    warningWithoutStack$1(
       false,
       "Can't call setState (or forceUpdate) on an unmounted component. This " +
         "is a no-op, but it indicates a memory leak in your application. To " +
         "fix, cancel all subscriptions and asynchronous tasks in the " +
         "componentWillUnmount method.%s",
-      getStackAddendumByWorkInProgressFiber(fiber)
+      getStackByFiberInDevAndProd(fiber)
     );
     didWarnStateUpdateForUnmountedComponent[componentName] = true;
   };
 
   warnAboutInvalidUpdates = function(instance) {
-    switch (ReactDebugCurrentFiber.phase) {
+    switch (phase) {
       case "getChildContext":
         if (didWarnSetStateChildContext) {
           return;
         }
-        warning(
+        warningWithoutStack$1(
           false,
           "setState(...): Cannot call setState() inside getChildContext()"
         );
@@ -12414,7 +12932,7 @@ var warnAboutInvalidUpdates = void 0;
         if (didWarnAboutStateTransition) {
           return;
         }
-        warning(
+        warningWithoutStack$1(
           false,
           "Cannot update during an existing state transition (such as within " +
             "`render` or another component's constructor). Render methods should " +
@@ -12427,12 +12945,7 @@ var warnAboutInvalidUpdates = void 0;
   };
 }
 
-// Represents the current time in ms.
-var originalStartTimeMs = now();
-var mostRecentCurrentTime = msToExpirationTime(0);
-var mostRecentCurrentTimeMs = originalStartTimeMs;
-
-// Used to ensure computeUniqueAsyncExpiration is monotonically increases.
+// Used to ensure computeUniqueAsyncExpiration is monotonically increasing.
 var lastUniqueAsyncExpiration = 0;
 
 // Represents the expiration time that incoming updates should use. (If this
@@ -12447,7 +12960,7 @@ var nextUnitOfWork = null;
 var nextRoot = null;
 // The time at which we're currently rendering work.
 var nextRenderExpirationTime = NoWork;
-var nextLatestTimeoutMs = -1;
+var nextLatestAbsoluteTimeoutMs = -1;
 var nextRenderDidError = false;
 
 // The next fiber with an effect that we're currently committing.
@@ -12484,7 +12997,7 @@ if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
     // Restore the original state of the work-in-progress
     if (stashedWorkInProgressProperties === null) {
       // This should never happen. Don't throw because this code is DEV-only.
-      warning(
+      warningWithoutStack$1(
         false,
         "Could not replay rendering after an error. This is likely a bug in React. " +
           "Please file an issue."
@@ -12546,6 +13059,12 @@ function resetStack() {
   if (nextUnitOfWork !== null) {
     var interruptedWork = nextUnitOfWork.return;
     while (interruptedWork !== null) {
+      if (enableProfilerTimer) {
+        if (interruptedWork.mode & ProfileMode) {
+          // Resume in case we're picking up on work that was paused.
+          resumeActualRenderTimerIfPaused(false);
+        }
+      }
       unwindInterruptedWork(interruptedWork);
       interruptedWork = interruptedWork.return;
     }
@@ -12558,7 +13077,7 @@ function resetStack() {
 
   nextRoot = null;
   nextRenderExpirationTime = NoWork;
-  nextLatestTimeoutMs = -1;
+  nextLatestAbsoluteTimeoutMs = -1;
   nextRenderDidError = false;
   nextUnitOfWork = null;
 }
@@ -12566,7 +13085,7 @@ function resetStack() {
 function commitAllHostEffects() {
   while (nextEffect !== null) {
     {
-      ReactDebugCurrentFiber.setCurrentFiber(nextEffect);
+      setCurrentFiber(nextEffect);
     }
     recordEffect();
 
@@ -12577,9 +13096,9 @@ function commitAllHostEffects() {
     }
 
     if (effectTag & Ref) {
-      var current = nextEffect.alternate;
-      if (current !== null) {
-        commitDetachRef(current);
+      var current$$1 = nextEffect.alternate;
+      if (current$$1 !== null) {
+        commitDetachRef(current$$1);
       }
     }
 
@@ -12625,31 +13144,34 @@ function commitAllHostEffects() {
   }
 
   {
-    ReactDebugCurrentFiber.resetCurrentFiber();
+    resetCurrentFiber();
   }
 }
 
 function commitBeforeMutationLifecycles() {
   while (nextEffect !== null) {
-    var effectTag = nextEffect.effectTag;
+    {
+      setCurrentFiber(nextEffect);
+    }
 
+    var effectTag = nextEffect.effectTag;
     if (effectTag & Snapshot) {
       recordEffect();
-      var current = nextEffect.alternate;
-      commitBeforeMutationLifeCycles(current, nextEffect);
+      var current$$1 = nextEffect.alternate;
+      commitBeforeMutationLifeCycles(current$$1, nextEffect);
     }
 
     // Don't cleanup effects yet;
     // This will be done by commitAllLifeCycles()
     nextEffect = nextEffect.nextEffect;
   }
+
+  {
+    resetCurrentFiber();
+  }
 }
 
-function commitAllLifeCycles(
-  finishedRoot,
-  currentTime,
-  committedExpirationTime
-) {
+function commitAllLifeCycles(finishedRoot, committedExpirationTime) {
   {
     ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
 
@@ -12666,12 +13188,11 @@ function commitAllLifeCycles(
 
     if (effectTag & (Update | Callback)) {
       recordEffect();
-      var current = nextEffect.alternate;
+      var current$$1 = nextEffect.alternate;
       commitLifeCycles(
         finishedRoot,
-        current,
+        current$$1,
         nextEffect,
-        currentTime,
         committedExpirationTime
       );
     }
@@ -12730,12 +13251,18 @@ function commitRoot(root, finishedWork) {
   // Update the pending priority levels to account for the work that we are
   // about to commit. This needs to happen before calling the lifecycles, since
   // they may schedule additional updates.
-  var earliestRemainingTime = finishedWork.expirationTime;
-  var currentTime = recalculateCurrentTime();
-  markCommittedPriorityLevels(root, currentTime, earliestRemainingTime);
+  var updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
+  var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
+  var earliestRemainingTimeBeforeCommit =
+    updateExpirationTimeBeforeCommit === NoWork ||
+    (childExpirationTimeBeforeCommit !== NoWork &&
+      childExpirationTimeBeforeCommit < updateExpirationTimeBeforeCommit)
+      ? childExpirationTimeBeforeCommit
+      : updateExpirationTimeBeforeCommit;
+  markCommittedPriorityLevels(root, earliestRemainingTimeBeforeCommit);
 
   // Reset this to null before calling lifecycles
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
 
   var firstEffect = void 0;
   if (finishedWork.effectTag > PerformedWork) {
@@ -12843,7 +13370,6 @@ function commitRoot(root, finishedWork) {
         commitAllLifeCycles,
         null,
         root,
-        currentTime,
         committedExpirationTime
       );
       if (hasCaughtError()) {
@@ -12866,84 +13392,100 @@ function commitRoot(root, finishedWork) {
 
   if (enableProfilerTimer) {
     {
-      checkActualRenderTimeStackEmpty();
+      if (nextRoot === null) {
+        // Only check this stack once we're done processing async work.
+        // This prevents a false positive that occurs after a batched commit,
+        // If there was in-progress async work before the commit.
+        checkActualRenderTimeStackEmpty();
+      }
     }
-    resetActualRenderTimer();
   }
 
   isCommitting$1 = false;
   isWorking = false;
   stopCommitLifeCyclesTimer();
   stopCommitTimer();
-  if (typeof onCommitRoot === "function") {
-    onCommitRoot(finishedWork.stateNode);
-  }
+  onCommitRoot(finishedWork.stateNode);
   if (true && ReactFiberInstrumentation_1.debugTool) {
     ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
   }
 
-  var expirationTime = root.expirationTime;
-  if (expirationTime === NoWork) {
+  var updateExpirationTimeAfterCommit = finishedWork.expirationTime;
+  var childExpirationTimeAfterCommit = finishedWork.childExpirationTime;
+  var earliestRemainingTimeAfterCommit =
+    updateExpirationTimeAfterCommit === NoWork ||
+    (childExpirationTimeAfterCommit !== NoWork &&
+      childExpirationTimeAfterCommit < updateExpirationTimeAfterCommit)
+      ? childExpirationTimeAfterCommit
+      : updateExpirationTimeAfterCommit;
+  if (earliestRemainingTimeAfterCommit === NoWork) {
     // If there's no remaining work, we can clear the set of already failed
     // error boundaries.
     legacyErrorBoundariesThatAlreadyFailed = null;
   }
-  onCommit(root, expirationTime);
+  onCommit(root, earliestRemainingTimeAfterCommit);
 }
 
-function resetExpirationTime(workInProgress, renderTime) {
-  if (renderTime !== Never && workInProgress.expirationTime === Never) {
+function resetChildExpirationTime(workInProgress, renderTime) {
+  if (renderTime !== Never && workInProgress.childExpirationTime === Never) {
     // The children of this component are hidden. Don't bubble their
     // expiration times.
     return;
   }
 
-  // Check for pending updates.
-  var newExpirationTime = NoWork;
-  switch (workInProgress.tag) {
-    case HostRoot:
-    case ClassComponent: {
-      var updateQueue = workInProgress.updateQueue;
-      if (updateQueue !== null) {
-        newExpirationTime = updateQueue.expirationTime;
-      }
-    }
-  }
-
-  // TODO: Calls need to visit stateNode
+  var newChildExpirationTime = NoWork;
 
   // Bubble up the earliest expiration time.
-  // (And "base" render timers if that feature flag is enabled)
   if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
-    var treeBaseTime = workInProgress.selfBaseTime;
+    // We're in profiling mode. Let's use this same traversal to update the
+    // "base" render times.
+    var treeBaseDuration = workInProgress.selfBaseDuration;
     var child = workInProgress.child;
     while (child !== null) {
-      treeBaseTime += child.treeBaseTime;
+      var childUpdateExpirationTime = child.expirationTime;
+      var childChildExpirationTime = child.childExpirationTime;
       if (
-        child.expirationTime !== NoWork &&
-        (newExpirationTime === NoWork ||
-          newExpirationTime > child.expirationTime)
+        newChildExpirationTime === NoWork ||
+        (childUpdateExpirationTime !== NoWork &&
+          childUpdateExpirationTime < newChildExpirationTime)
       ) {
-        newExpirationTime = child.expirationTime;
+        newChildExpirationTime = childUpdateExpirationTime;
       }
+      if (
+        newChildExpirationTime === NoWork ||
+        (childChildExpirationTime !== NoWork &&
+          childChildExpirationTime < newChildExpirationTime)
+      ) {
+        newChildExpirationTime = childChildExpirationTime;
+      }
+      treeBaseDuration += child.treeBaseDuration;
       child = child.sibling;
     }
-    workInProgress.treeBaseTime = treeBaseTime;
+    workInProgress.treeBaseDuration = treeBaseDuration;
   } else {
     var _child = workInProgress.child;
     while (_child !== null) {
+      var _childUpdateExpirationTime = _child.expirationTime;
+      var _childChildExpirationTime = _child.childExpirationTime;
       if (
-        _child.expirationTime !== NoWork &&
-        (newExpirationTime === NoWork ||
-          newExpirationTime > _child.expirationTime)
+        newChildExpirationTime === NoWork ||
+        (_childUpdateExpirationTime !== NoWork &&
+          _childUpdateExpirationTime < newChildExpirationTime)
       ) {
-        newExpirationTime = _child.expirationTime;
+        newChildExpirationTime = _childUpdateExpirationTime;
+      }
+      if (
+        newChildExpirationTime === NoWork ||
+        (_childChildExpirationTime !== NoWork &&
+          _childChildExpirationTime < newChildExpirationTime)
+      ) {
+        newChildExpirationTime = _childChildExpirationTime;
       }
       _child = _child.sibling;
     }
   }
 
-  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.childExpirationTime = newChildExpirationTime;
 }
 
 function completeUnitOfWork(workInProgress) {
@@ -12955,9 +13497,9 @@ function completeUnitOfWork(workInProgress) {
     // Ideally nothing should rely on this, but relying on it here
     // means that we don't need an additional field on the work in
     // progress.
-    var current = workInProgress.alternate;
+    var current$$1 = workInProgress.alternate;
     {
-      ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
+      setCurrentFiber(workInProgress);
     }
 
     var returnFiber = workInProgress.return;
@@ -12965,15 +13507,16 @@ function completeUnitOfWork(workInProgress) {
 
     if ((workInProgress.effectTag & Incomplete) === NoEffect) {
       // This fiber completed.
-      var next = completeWork(
-        current,
+      nextUnitOfWork = completeWork(
+        current$$1,
         workInProgress,
         nextRenderExpirationTime
       );
+      var next = nextUnitOfWork;
       stopWorkTimer(workInProgress);
-      resetExpirationTime(workInProgress, nextRenderExpirationTime);
+      resetChildExpirationTime(workInProgress, nextRenderExpirationTime);
       {
-        ReactDebugCurrentFiber.resetCurrentFiber();
+        resetCurrentFiber();
       }
 
       if (next !== null) {
@@ -13052,7 +13595,7 @@ function completeUnitOfWork(workInProgress) {
       }
 
       {
-        ReactDebugCurrentFiber.resetCurrentFiber();
+        resetCurrentFiber();
       }
 
       if (_next !== null) {
@@ -13060,6 +13603,7 @@ function completeUnitOfWork(workInProgress) {
         if (true && ReactFiberInstrumentation_1.debugTool) {
           ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
         }
+
         // If completing this work spawned new work, do that next. We'll come
         // back here again.
         // Since we're restarting, remove anything that is not a host effect
@@ -13102,12 +13646,12 @@ function performUnitOfWork(workInProgress) {
   // Ideally nothing should rely on this, but relying on it here
   // means that we don't need an additional field on the work in
   // progress.
-  var current = workInProgress.alternate;
+  var current$$1 = workInProgress.alternate;
 
   // See if beginning this work spawns more work.
   startWorkTimer(workInProgress);
   {
-    ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
+    setCurrentFiber(workInProgress);
   }
 
   if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
@@ -13123,7 +13667,7 @@ function performUnitOfWork(workInProgress) {
       startBaseRenderTimer();
     }
 
-    next = beginWork(current, workInProgress, nextRenderExpirationTime);
+    next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
 
     if (workInProgress.mode & ProfileMode) {
       // Update "base" time if the render wasn't bailed out on.
@@ -13131,11 +13675,11 @@ function performUnitOfWork(workInProgress) {
       stopBaseRenderTimerIfRunning();
     }
   } else {
-    next = beginWork(current, workInProgress, nextRenderExpirationTime);
+    next = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
   }
 
   {
-    ReactDebugCurrentFiber.resetCurrentFiber();
+    resetCurrentFiber();
     if (isReplayingFailedUnitOfWork) {
       // Currently replaying a failed unit of work. This should be unreachable,
       // because the render phase is meant to be idempotent, and it should
@@ -13153,7 +13697,7 @@ function performUnitOfWork(workInProgress) {
     next = completeUnitOfWork(workInProgress);
   }
 
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
 
   return next;
 }
@@ -13178,13 +13722,14 @@ function workLoop(isYieldy) {
   }
 }
 
-function renderRoot(root, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused " +
       "by a bug in React. Please file an issue."
   );
   isWorking = true;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
 
   var expirationTime = root.nextExpirationTimeToWorkOn;
 
@@ -13199,8 +13744,6 @@ function renderRoot(root, isYieldy) {
     resetStack();
     nextRoot = root;
     nextRenderExpirationTime = expirationTime;
-    nextLatestTimeoutMs = -1;
-    nextRenderDidError = false;
     nextUnitOfWork = createWorkInProgress(
       nextRoot.current,
       null,
@@ -13259,17 +13802,17 @@ function renderRoot(root, isYieldy) {
           // for now.
           didFatal = true;
           onUncaughtError(thrownValue);
-          break;
+        } else {
+          throwException(
+            root,
+            returnFiber,
+            sourceFiber,
+            thrownValue,
+            nextRenderExpirationTime
+          );
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        throwException(
-          root,
-          returnFiber,
-          sourceFiber,
-          thrownValue,
-          nextRenderExpirationTime,
-          mostRecentCurrentTimeMs
-        );
-        nextUnitOfWork = completeUnitOfWork(sourceFiber);
       }
     }
     break;
@@ -13277,52 +13820,139 @@ function renderRoot(root, isYieldy) {
 
   // We're done performing work. Time to clean up.
   isWorking = false;
+  ReactCurrentOwner$2.currentDispatcher = null;
+  resetContextDependences();
 
   // Yield back to main thread.
   if (didFatal) {
-    var didCompleteRoot = false;
-    stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+    var _didCompleteRoot = false;
+    stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
     interruptedBy = null;
     // There was a fatal error.
     {
       resetStackAfterFatalErrorInDev();
+
+      // Reset the DEV fiber stack in case we're profiling roots.
+      // (We do this for profiling bulds when DevTools is detected.)
+      resetActualRenderTimerStackAfterFatalErrorInDev();
     }
+    // `nextRoot` points to the in-progress root. A non-null value indicates
+    // that we're in the middle of an async render. Set it to null to indicate
+    // there's no more work to be done in the current batch.
+    nextRoot = null;
     onFatal(root);
-  } else if (nextUnitOfWork === null) {
-    // We reached the root.
-    var rootWorkInProgress = root.current.alternate;
-    invariant(
-      rootWorkInProgress !== null,
-      "Finished root should have a work-in-progress. This error is likely " +
-        "caused by a bug in React. Please file an issue."
-    );
-    if ((rootWorkInProgress.effectTag & Incomplete) === NoEffect) {
-      var _didCompleteRoot = true;
-      stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
-      interruptedBy = null;
-      // The root successfully completed.
-      onComplete(root, rootWorkInProgress, expirationTime);
-    } else {
-      // The root did not complete.
-      var _didCompleteRoot2 = false;
-      stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
-      interruptedBy = null;
-      markSuspendedPriorityLevel(root, expirationTime, nextRenderDidError);
-      var suspendedExpirationTime = expirationTime;
-      var newExpirationTime = root.expirationTime;
-      onSuspend(
-        root,
-        suspendedExpirationTime,
-        newExpirationTime,
-        nextLatestTimeoutMs
-      );
-    }
-  } else {
-    var _didCompleteRoot3 = false;
-    stopWorkLoopTimer(interruptedBy, _didCompleteRoot3);
+    return;
+  }
+
+  if (nextUnitOfWork !== null) {
+    // There's still remaining async work in this tree, but we ran out of time
+    // in the current frame. Yield back to the renderer. Unless we're
+    // interrupted by a higher priority update, we'll continue later from where
+    // we left off.
+    var _didCompleteRoot2 = false;
+    stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
     interruptedBy = null;
     onYield(root);
+    return;
   }
+
+  // We completed the whole tree.
+  var didCompleteRoot = true;
+  stopWorkLoopTimer(interruptedBy, didCompleteRoot);
+  var rootWorkInProgress = root.current.alternate;
+  invariant(
+    rootWorkInProgress !== null,
+    "Finished root should have a work-in-progress. This error is likely " +
+      "caused by a bug in React. Please file an issue."
+  );
+
+  // `nextRoot` points to the in-progress root. A non-null value indicates
+  // that we're in the middle of an async render. Set it to null to indicate
+  // there's no more work to be done in the current batch.
+  nextRoot = null;
+  interruptedBy = null;
+
+  if (nextRenderDidError) {
+    // There was an error
+    if (hasLowerPriorityWork(root, expirationTime)) {
+      // There's lower priority work. If so, it may have the effect of fixing
+      // the exception that was just thrown. Exit without committing. This is
+      // similar to a suspend, but without a timeout because we're not waiting
+      // for a promise to resolve. React will restart at the lower
+      // priority level.
+      markSuspendedPriorityLevel(root, expirationTime);
+      var suspendedExpirationTime = expirationTime;
+      var rootExpirationTime = root.expirationTime;
+      onSuspend(
+        root,
+        rootWorkInProgress,
+        suspendedExpirationTime,
+        rootExpirationTime,
+        -1 // Indicates no timeout
+      );
+      return;
+    } else if (
+      // There's no lower priority work, but we're rendering asynchronously.
+      // Synchronsouly attempt to render the same level one more time. This is
+      // similar to a suspend, but without a timeout because we're not waiting
+      // for a promise to resolve.
+      !root.didError &&
+      !isExpired
+    ) {
+      root.didError = true;
+      var _suspendedExpirationTime = (root.nextExpirationTimeToWorkOn = expirationTime);
+      var _rootExpirationTime = (root.expirationTime = Sync);
+      onSuspend(
+        root,
+        rootWorkInProgress,
+        _suspendedExpirationTime,
+        _rootExpirationTime,
+        -1 // Indicates no timeout
+      );
+      return;
+    }
+  }
+
+  if (enableSuspense && !isExpired && nextLatestAbsoluteTimeoutMs !== -1) {
+    // The tree was suspended.
+    var _suspendedExpirationTime2 = expirationTime;
+    markSuspendedPriorityLevel(root, _suspendedExpirationTime2);
+
+    // Find the earliest uncommitted expiration time in the tree, including
+    // work that is suspended. The timeout threshold cannot be longer than
+    // the overall expiration.
+    var earliestExpirationTime = findEarliestOutstandingPriorityLevel(
+      root,
+      expirationTime
+    );
+    var earliestExpirationTimeMs = expirationTimeToMs(earliestExpirationTime);
+    if (earliestExpirationTimeMs < nextLatestAbsoluteTimeoutMs) {
+      nextLatestAbsoluteTimeoutMs = earliestExpirationTimeMs;
+    }
+
+    // Subtract the current time from the absolute timeout to get the number
+    // of milliseconds until the timeout. In other words, convert an absolute
+    // timestamp to a relative time. This is the value that is passed
+    // to `setTimeout`.
+    var currentTimeMs = expirationTimeToMs(requestCurrentTime());
+    var msUntilTimeout = nextLatestAbsoluteTimeoutMs - currentTimeMs;
+    msUntilTimeout = msUntilTimeout < 0 ? 0 : msUntilTimeout;
+
+    // TODO: Account for the Just Noticable Difference
+
+    var _rootExpirationTime2 = root.expirationTime;
+    onSuspend(
+      root,
+      rootWorkInProgress,
+      _suspendedExpirationTime2,
+      _rootExpirationTime2,
+      msUntilTimeout
+    );
+    return;
+  }
+
+  // Ready to commit.
+  onComplete(root, rootWorkInProgress, expirationTime);
 }
 
 function dispatch(sourceFiber, value, expirationTime) {
@@ -13344,7 +13974,7 @@ function dispatch(sourceFiber, value, expirationTime) {
         ) {
           var errorInfo = createCapturedValue(value, sourceFiber);
           var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
-          enqueueUpdate(fiber, update, expirationTime);
+          enqueueUpdate(fiber, update);
           scheduleWork(fiber, expirationTime);
           return;
         }
@@ -13352,7 +13982,7 @@ function dispatch(sourceFiber, value, expirationTime) {
       case HostRoot: {
         var _errorInfo = createCapturedValue(value, sourceFiber);
         var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);
-        enqueueUpdate(fiber, _update, expirationTime);
+        enqueueUpdate(fiber, _update);
         scheduleWork(fiber, expirationTime);
         return;
       }
@@ -13370,7 +14000,7 @@ function dispatch(sourceFiber, value, expirationTime) {
       _errorInfo2,
       expirationTime
     );
-    enqueueUpdate(rootFiber, _update2, expirationTime);
+    enqueueUpdate(rootFiber, _update2);
     scheduleWork(rootFiber, expirationTime);
   }
 }
@@ -13379,36 +14009,9 @@ function captureCommitPhaseError(fiber, error) {
   return dispatch(fiber, error, Sync);
 }
 
-function computeAsyncExpiration(currentTime) {
-  // Given the current clock time, returns an expiration time. We use rounding
-  // to batch like updates together.
-  // Should complete within ~5000ms. 5250ms max.
-  var expirationMs = 5000;
-  var bucketSizeMs = 250;
-  return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
-}
-
-function computeInteractiveExpiration(currentTime) {
-  var expirationMs = void 0;
-  // We intentionally set a higher expiration time for interactive updates in
-  // dev than in production.
-  // If the main thread is being blocked so long that you hit the expiration,
-  // it's a problem that could be solved with better scheduling.
-  // People will be more likely to notice this and fix it with the long
-  // expiration time in development.
-  // In production we opt for better UX at the risk of masking scheduling
-  // problems, by expiring fast.
-  {
-    // Should complete within ~500ms. 600ms max.
-    expirationMs = 500;
-  }
-  var bucketSizeMs = 100;
-  return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
-}
-
 // Creates a unique async expiration time.
 function computeUniqueAsyncExpiration() {
-  var currentTime = recalculateCurrentTime();
+  var currentTime = requestCurrentTime();
   var result = computeAsyncExpiration(currentTime);
   if (result <= lastUniqueAsyncExpiration) {
     // Since we assume the current time monotonically increases, we only hit
@@ -13446,6 +14049,11 @@ function computeExpirationForFiber(currentTime, fiber) {
         // This is an async update
         expirationTime = computeAsyncExpiration(currentTime);
       }
+      // If we're in the middle of rendering a tree, do not update at the same
+      // expiration time that is already rendering.
+      if (nextRoot !== null && expirationTime === nextRenderExpirationTime) {
+        expirationTime += 1;
+      }
     } else {
       // This is a sync update
       expirationTime = Sync;
@@ -13465,25 +14073,93 @@ function computeExpirationForFiber(currentTime, fiber) {
   return expirationTime;
 }
 
-function markTimeout(root, thenable, timeoutMs, suspendedTime) {
+function renderDidSuspend(root, absoluteTimeoutMs, suspendedTime) {
   // Schedule the timeout.
-  if (timeoutMs >= 0 && nextLatestTimeoutMs < timeoutMs) {
-    nextLatestTimeoutMs = timeoutMs;
+  if (
+    absoluteTimeoutMs >= 0 &&
+    nextLatestAbsoluteTimeoutMs < absoluteTimeoutMs
+  ) {
+    nextLatestAbsoluteTimeoutMs = absoluteTimeoutMs;
   }
 }
 
-function markError(root) {
+function renderDidError() {
   nextRenderDidError = true;
 }
 
-function retrySuspendedRoot(root, suspendedTime) {
-  markPingedPriorityLevel(root, suspendedTime);
-  var retryTime = root.expirationTime;
-  if (retryTime !== NoWork) {
-    requestWork(root, retryTime);
+function retrySuspendedRoot(root, fiber, suspendedTime) {
+  if (enableSuspense) {
+    var retryTime = void 0;
+
+    if (isPriorityLevelSuspended(root, suspendedTime)) {
+      // Ping at the original level
+      retryTime = suspendedTime;
+      markPingedPriorityLevel(root, retryTime);
+    } else {
+      // Placeholder already timed out. Compute a new expiration time
+      var currentTime = requestCurrentTime();
+      retryTime = computeExpirationForFiber(currentTime, fiber);
+      markPendingPriorityLevel(root, retryTime);
+    }
+
+    scheduleWorkToRoot(fiber, retryTime);
+    var rootExpirationTime = root.expirationTime;
+    if (rootExpirationTime !== NoWork) {
+      requestWork(root, rootExpirationTime);
+    }
   }
 }
 
+function scheduleWorkToRoot(fiber, expirationTime) {
+  // Update the source fiber's expiration time
+  if (
+    fiber.expirationTime === NoWork ||
+    fiber.expirationTime > expirationTime
+  ) {
+    fiber.expirationTime = expirationTime;
+  }
+  var alternate = fiber.alternate;
+  if (
+    alternate !== null &&
+    (alternate.expirationTime === NoWork ||
+      alternate.expirationTime > expirationTime)
+  ) {
+    alternate.expirationTime = expirationTime;
+  }
+  // Walk the parent path to the root and update the child expiration time.
+  var node = fiber.return;
+  if (node === null && fiber.tag === HostRoot) {
+    return fiber.stateNode;
+  }
+  while (node !== null) {
+    alternate = node.alternate;
+    if (
+      node.childExpirationTime === NoWork ||
+      node.childExpirationTime > expirationTime
+    ) {
+      node.childExpirationTime = expirationTime;
+      if (
+        alternate !== null &&
+        (alternate.childExpirationTime === NoWork ||
+          alternate.childExpirationTime > expirationTime)
+      ) {
+        alternate.childExpirationTime = expirationTime;
+      }
+    } else if (
+      alternate !== null &&
+      (alternate.childExpirationTime === NoWork ||
+        alternate.childExpirationTime > expirationTime)
+    ) {
+      alternate.childExpirationTime = expirationTime;
+    }
+    if (node.return === null && node.tag === HostRoot) {
+      return node.stateNode;
+    }
+    node = node.return;
+  }
+  return null;
+}
+
 function scheduleWork(fiber, expirationTime) {
   recordScheduleUpdate();
 
@@ -13494,80 +14170,51 @@ function scheduleWork(fiber, expirationTime) {
     }
   }
 
-  var node = fiber;
-  while (node !== null) {
-    // Walk the parent path to the root and update each node's
-    // expiration time.
-    if (
-      node.expirationTime === NoWork ||
-      node.expirationTime > expirationTime
-    ) {
-      node.expirationTime = expirationTime;
+  var root = scheduleWorkToRoot(fiber, expirationTime);
+  if (root === null) {
+    if (true && fiber.tag === ClassComponent) {
+      warnAboutUpdateOnUnmounted(fiber);
     }
-    if (node.alternate !== null) {
-      if (
-        node.alternate.expirationTime === NoWork ||
-        node.alternate.expirationTime > expirationTime
-      ) {
-        node.alternate.expirationTime = expirationTime;
-      }
-    }
-    if (node.return === null) {
-      if (node.tag === HostRoot) {
-        var root = node.stateNode;
-        if (
-          !isWorking &&
-          nextRenderExpirationTime !== NoWork &&
-          expirationTime < nextRenderExpirationTime
-        ) {
-          // This is an interruption. (Used for performance tracking.)
-          interruptedBy = fiber;
-          resetStack();
-        }
-        markPendingPriorityLevel(root, expirationTime);
-        if (
-          // If we're in the render phase, we don't need to schedule this root
-          // for an update, because we'll do it before we exit...
-          !isWorking ||
-          isCommitting$1 ||
-          // ...unless this is a different root than the one we're rendering.
-          nextRoot !== root
-        ) {
-          var rootExpirationTime = root.expirationTime;
-          requestWork(root, rootExpirationTime);
-        }
-        if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
-          invariant(
-            false,
-            "Maximum update depth exceeded. This can happen when a " +
-              "component repeatedly calls setState inside " +
-              "componentWillUpdate or componentDidUpdate. React limits " +
-              "the number of nested updates to prevent infinite loops."
-          );
-        }
-      } else {
-        {
-          if (fiber.tag === ClassComponent) {
-            warnAboutUpdateOnUnmounted(fiber);
-          }
-        }
-        return;
-      }
-    }
-    node = node.return;
+    return;
+  }
+
+  if (
+    !isWorking &&
+    nextRenderExpirationTime !== NoWork &&
+    expirationTime < nextRenderExpirationTime
+  ) {
+    // This is an interruption. (Used for performance tracking.)
+    interruptedBy = fiber;
+    resetStack();
+  }
+  markPendingPriorityLevel(root, expirationTime);
+  if (
+    // If we're in the render phase, we don't need to schedule this root
+    // for an update, because we'll do it before we exit...
+    !isWorking ||
+    isCommitting$1 ||
+    // ...unless this is a different root than the one we're rendering.
+    nextRoot !== root
+  ) {
+    var rootExpirationTime = root.expirationTime;
+    requestWork(root, rootExpirationTime);
+  }
+  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
+    // Reset this back to zero so subsequent updates don't throw.
+    nestedUpdateCount = 0;
+    invariant(
+      false,
+      "Maximum update depth exceeded. This can happen when a " +
+        "component repeatedly calls setState inside " +
+        "componentWillUpdate or componentDidUpdate. React limits " +
+        "the number of nested updates to prevent infinite loops."
+    );
   }
 }
 
-function recalculateCurrentTime() {
-  // Subtract initial time so it fits inside 32bits
-  mostRecentCurrentTimeMs = now() - originalStartTimeMs;
-  mostRecentCurrentTime = msToExpirationTime(mostRecentCurrentTimeMs);
-  return mostRecentCurrentTime;
-}
-
 function deferredUpdates(fn) {
+  var currentTime = requestCurrentTime();
   var previousExpirationContext = expirationContext;
-  var currentTime = recalculateCurrentTime();
   expirationContext = computeAsyncExpiration(currentTime);
   try {
     return fn();
@@ -13575,6 +14222,7 @@ function deferredUpdates(fn) {
     expirationContext = previousExpirationContext;
   }
 }
+
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
   expirationContext = Sync;
@@ -13609,12 +14257,22 @@ var isBatchingInteractiveUpdates = false;
 
 var completedBatches = null;
 
+var originalStartTimeMs = now();
+var currentRendererTime = msToExpirationTime(originalStartTimeMs);
+var currentSchedulerTime = currentRendererTime;
+
 // Use these to prevent an infinite loop of nested updates
-var NESTED_UPDATE_LIMIT = 1000;
+var NESTED_UPDATE_LIMIT = 50;
 var nestedUpdateCount = 0;
+var lastCommittedRootDuringThisBatch = null;
 
 var timeHeuristicForUnitOfWork = 1;
 
+function recomputeCurrentRendererTime() {
+  var currentTimeMs = now() - originalStartTimeMs;
+  currentRendererTime = msToExpirationTime(currentTimeMs);
+}
+
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (callbackExpirationTime !== NoWork) {
     // A callback is already scheduled. Check its expiration time (timeout).
@@ -13653,30 +14311,98 @@ function onComplete(root, finishedWork, expirationTime) {
   root.finishedWork = finishedWork;
 }
 
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  if (timeoutMs >= 0) {
-    var suspendedRoot = root;
-    setTimeout(function() {
-      retrySuspendedRoot(suspendedRoot, suspendedExpirationTime);
-    }, timeoutMs);
+function onSuspend(
+  root,
+  finishedWork,
+  suspendedExpirationTime,
+  rootExpirationTime,
+  msUntilTimeout
+) {
+  root.expirationTime = rootExpirationTime;
+  if (enableSuspense && msUntilTimeout === 0 && !shouldYield()) {
+    // Don't wait an additional tick. Commit the tree immediately.
+    root.pendingCommitExpirationTime = suspendedExpirationTime;
+    root.finishedWork = finishedWork;
+  } else if (msUntilTimeout > 0) {
+    // Wait `msUntilTimeout` milliseconds before committing.
+    root.timeoutHandle = scheduleTimeout(
+      onTimeout.bind(null, root, finishedWork, suspendedExpirationTime),
+      msUntilTimeout
+    );
   }
-  root.expirationTime = expirationTime;
 }
 
 function onYield(root) {
   root.finishedWork = null;
 }
 
+function onTimeout(root, finishedWork, suspendedExpirationTime) {
+  if (enableSuspense) {
+    // The root timed out. Commit it.
+    root.pendingCommitExpirationTime = suspendedExpirationTime;
+    root.finishedWork = finishedWork;
+    // Read the current time before entering the commit phase. We can be
+    // certain this won't cause tearing related to batching of event updates
+    // because we're at the top of a timer event.
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+    flushRoot(root, suspendedExpirationTime);
+  }
+}
+
 function onCommit(root, expirationTime) {
   root.expirationTime = expirationTime;
   root.finishedWork = null;
 }
 
+function requestCurrentTime() {
+  // requestCurrentTime is called by the scheduler to compute an expiration
+  // time.
+  //
+  // Expiration times are computed by adding to the current time (the start
+  // time). However, if two updates are scheduled within the same event, we
+  // should treat their start times as simultaneous, even if the actual clock
+  // time has advanced between the first and second call.
+
+  // In other words, because expiration times determine how updates are batched,
+  // we want all updates of like priority that occur within the same event to
+  // receive the same expiration time. Otherwise we get tearing.
+  //
+  // We keep track of two separate times: the current "renderer" time and the
+  // current "scheduler" time. The renderer time can be updated whenever; it
+  // only exists to minimize the calls performance.now.
+  //
+  // But the scheduler time can only be updated if there's no pending work, or
+  // if we know for certain that we're not in the middle of an event.
+
+  if (isRendering) {
+    // We're already rendering. Return the most recently read time.
+    return currentSchedulerTime;
+  }
+  // Check if there's pending work.
+  findHighestPriorityRoot();
+  if (
+    nextFlushedExpirationTime === NoWork ||
+    nextFlushedExpirationTime === Never
+  ) {
+    // If there's no pending work, or if the pending work is offscreen, we can
+    // read the current time without risk of tearing.
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+    return currentSchedulerTime;
+  }
+  // There's already pending work. We might be in the middle of a browser
+  // event. If we were to read the current time, it could cause multiple updates
+  // within the same event to receive different expiration times, leading to
+  // tearing. Return the last read time. During the next idle callback, the
+  // time will be updated.
+  return currentSchedulerTime;
+}
+
 // requestWork is called by the scheduler whenever a root receives an update.
 // It's up to the renderer to call renderRoot at some point in the future.
 function requestWork(root, expirationTime) {
   addRootToSchedule(root, expirationTime);
-
   if (isRendering) {
     // Prevent reentrancy. Remaining work will be scheduled at the end of
     // the currently rendering batch.
@@ -13690,7 +14416,7 @@ function requestWork(root, expirationTime) {
       // flush it now.
       nextFlushedRoot = root;
       nextFlushedExpirationTime = Sync;
-      performWorkOnRoot(root, Sync, false);
+      performWorkOnRoot(root, Sync, true);
     }
     return;
   }
@@ -13789,19 +14515,6 @@ function findHighestPriorityRoot() {
     }
   }
 
-  // If the next root is the same as the previous root, this is a nested
-  // update. To prevent an infinite loop, increment the nested update count.
-  var previousFlushedRoot = nextFlushedRoot;
-  if (
-    previousFlushedRoot !== null &&
-    previousFlushedRoot === highestPriorityRoot &&
-    highestPriorityWork === Sync
-  ) {
-    nestedUpdateCount++;
-  } else {
-    // Reset whenever we switch roots.
-    nestedUpdateCount = 0;
-  }
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -13822,27 +14535,34 @@ function performWork(minExpirationTime, dl) {
   findHighestPriorityRoot();
 
   if (enableProfilerTimer) {
-    resumeActualRenderTimerIfPaused();
-  }
-
-  if (enableUserTimingAPI && deadline !== null) {
-    var didExpire = nextFlushedExpirationTime < recalculateCurrentTime();
-    var timeout = expirationTimeToMs(nextFlushedExpirationTime);
-    stopRequestCallbackTimer(didExpire, timeout);
+    resumeActualRenderTimerIfPaused(minExpirationTime === Sync);
   }
 
   if (deadline !== null) {
+    recomputeCurrentRendererTime();
+    currentSchedulerTime = currentRendererTime;
+
+    if (enableUserTimingAPI) {
+      var didExpire = nextFlushedExpirationTime < currentRendererTime;
+      var timeout = expirationTimeToMs(nextFlushedExpirationTime);
+      stopRequestCallbackTimer(didExpire, timeout);
+    }
+
     while (
       nextFlushedRoot !== null &&
       nextFlushedExpirationTime !== NoWork &&
       (minExpirationTime === NoWork ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime)
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime)
     ) {
-      recalculateCurrentTime();
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      );
       findHighestPriorityRoot();
+      recomputeCurrentRendererTime();
+      currentSchedulerTime = currentRendererTime;
     }
   } else {
     while (
@@ -13851,7 +14571,7 @@ function performWork(minExpirationTime, dl) {
       (minExpirationTime === NoWork ||
         minExpirationTime >= nextFlushedExpirationTime)
     ) {
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
       findHighestPriorityRoot();
     }
   }
@@ -13887,14 +14607,15 @@ function flushRoot(root, expirationTime) {
   // including the given time.
   nextFlushedRoot = root;
   nextFlushedExpirationTime = expirationTime;
-  performWorkOnRoot(root, expirationTime, false);
+  performWorkOnRoot(root, expirationTime, true);
   // Flush any sync work that was scheduled by lifecycles
   performSyncWork();
-  finishRendering();
+  pauseActualRenderTimerIfRunning();
 }
 
 function finishRendering() {
   nestedUpdateCount = 0;
+  lastCommittedRootDuringThisBatch = null;
 
   if (completedBatches !== null) {
     var batches = completedBatches;
@@ -13920,7 +14641,7 @@ function finishRendering() {
   }
 }
 
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused " +
@@ -13930,15 +14651,28 @@ function performWorkOnRoot(root, expirationTime, isYieldy) {
   isRendering = true;
 
   // Check if this is async work or sync/expired work.
-  if (!isYieldy) {
+  if (deadline === null || isExpired) {
     // Flush work without yielding.
+    // TODO: Non-yieldy work does not necessarily imply expired work. A renderer
+    // may want to perform some work without yielding, but also without
+    // requiring the root to complete (by triggering placeholders).
+
     var finishedWork = root.finishedWork;
     if (finishedWork !== null) {
       // This root is already complete. We can commit it.
       completeRoot(root, finishedWork, expirationTime);
     } else {
       root.finishedWork = null;
-      renderRoot(root, false);
+      // If this root previously suspended, clear its existing timeout, since
+      // we're about to try rendering again.
+      var timeoutHandle = root.timeoutHandle;
+      if (enableSuspense && timeoutHandle !== noTimeout) {
+        root.timeoutHandle = noTimeout;
+        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+        cancelTimeout(timeoutHandle);
+      }
+      var isYieldy = false;
+      renderRoot(root, isYieldy, isExpired);
       finishedWork = root.finishedWork;
       if (finishedWork !== null) {
         // We've completed the root. Commit it.
@@ -13953,7 +14687,16 @@ function performWorkOnRoot(root, expirationTime, isYieldy) {
       completeRoot(root, _finishedWork, expirationTime);
     } else {
       root.finishedWork = null;
-      renderRoot(root, true);
+      // If this root previously suspended, clear its existing timeout, since
+      // we're about to try rendering again.
+      var _timeoutHandle = root.timeoutHandle;
+      if (enableSuspense && _timeoutHandle !== noTimeout) {
+        root.timeoutHandle = noTimeout;
+        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
+        cancelTimeout(_timeoutHandle);
+      }
+      var _isYieldy = true;
+      renderRoot(root, _isYieldy, isExpired);
       _finishedWork = root.finishedWork;
       if (_finishedWork !== null) {
         // We've completed the root. Check the deadline one more time
@@ -13999,16 +14742,31 @@ function completeRoot(root, finishedWork, expirationTime) {
 
   // Commit the root.
   root.finishedWork = null;
+
+  // Check if this is a nested update (a sync update scheduled during the
+  // commit phase).
+  if (root === lastCommittedRootDuringThisBatch) {
+    // If the next root is the same as the previous root, this is a nested
+    // update. To prevent an infinite loop, increment the nested update count.
+    nestedUpdateCount++;
+  } else {
+    // Reset whenever we switch roots.
+    lastCommittedRootDuringThisBatch = root;
+    nestedUpdateCount = 0;
+  }
   commitRoot(root, finishedWork);
 }
 
 // When working on async work, the reconciler asks the renderer if it should
 // yield execution. For DOM, we implement this with requestIdleCallback.
 function shouldYield() {
-  if (deadline === null || deadlineDidExpire) {
-    return false;
+  if (deadlineDidExpire) {
+    return true;
   }
-  if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
+  if (
+    deadline === null ||
+    deadline.timeRemaining() > timeHeuristicForUnitOfWork
+  ) {
     // Disregard deadline.didTimeout. Only expired work should be flushed
     // during a timeout. This path is only hit for non-expired work.
     return false;
@@ -14143,7 +14901,7 @@ var didWarnAboutNestedUpdates = void 0;
 
 function getContextForSubtree(parentComponent) {
   if (!parentComponent) {
-    return emptyObject;
+    return emptyContextObject;
   }
 
   var fiber = get$1(parentComponent);
@@ -14153,21 +14911,17 @@ function getContextForSubtree(parentComponent) {
     : parentContext;
 }
 
-function scheduleRootUpdate(current, element, expirationTime, callback) {
+function scheduleRootUpdate(current$$1, element, expirationTime, callback) {
   {
-    if (
-      ReactDebugCurrentFiber.phase === "render" &&
-      ReactDebugCurrentFiber.current !== null &&
-      !didWarnAboutNestedUpdates
-    ) {
+    if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
       didWarnAboutNestedUpdates = true;
-      warning(
+      warningWithoutStack$1(
         false,
         "Render methods should be a pure function of props and state; " +
           "triggering nested component updates from render is not allowed. " +
           "If necessary, trigger nested updates in componentDidUpdate.\n\n" +
           "Check the render method of %s.",
-        getComponentName(ReactDebugCurrentFiber.current) || "Unknown"
+        getComponentName(current.type) || "Unknown"
       );
     }
   }
@@ -14180,7 +14934,7 @@ function scheduleRootUpdate(current, element, expirationTime, callback) {
   callback = callback === undefined ? null : callback;
   if (callback !== null) {
     !(typeof callback === "function")
-      ? warning(
+      ? warningWithoutStack$1(
           false,
           "render(...): Expected the last optional `callback` argument to be a " +
             "function. Instead received: %s.",
@@ -14189,9 +14943,9 @@ function scheduleRootUpdate(current, element, expirationTime, callback) {
       : void 0;
     update.callback = callback;
   }
-  enqueueUpdate(current, update, expirationTime);
+  enqueueUpdate(current$$1, update);
 
-  scheduleWork(current, expirationTime);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 
@@ -14203,11 +14957,11 @@ function updateContainerAtExpirationTime(
   callback
 ) {
   // TODO: If this is a nested container, this won't be the root.
-  var current = container.current;
+  var current$$1 = container.current;
 
   {
     if (ReactFiberInstrumentation_1.debugTool) {
-      if (current.alternate === null) {
+      if (current$$1.alternate === null) {
         ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
       } else if (element === null) {
         ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
@@ -14224,7 +14978,7 @@ function updateContainerAtExpirationTime(
     container.pendingContext = context;
   }
 
-  return scheduleRootUpdate(current, element, expirationTime, callback);
+  return scheduleRootUpdate(current$$1, element, expirationTime, callback);
 }
 
 function findHostInstance$1(component) {
@@ -14252,9 +15006,9 @@ function createContainer(containerInfo, isAsync, hydrate) {
 }
 
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current;
-  var currentTime = recalculateCurrentTime();
-  var expirationTime = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current;
+  var currentTime = requestCurrentTime();
+  var expirationTime = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
@@ -14749,6 +15503,11 @@ var ReactNativeComponent = function(findNodeHandle, findHostInstance) {
 };
 
 // Module provided by RN:
+var emptyObject$2 = {};
+{
+  Object.freeze(emptyObject$2);
+}
+
 var getInspectorDataForViewTag = void 0;
 
 {
@@ -14779,9 +15538,9 @@ var getInspectorDataForViewTag = void 0;
   var getHostProps = function(fiber) {
     var host = findCurrentHostFiber(fiber);
     if (host) {
-      return host.memoizedProps || emptyObject;
+      return host.memoizedProps || emptyObject$2;
     }
-    return emptyObject;
+    return emptyObject$2;
   };
 
   var getHostNode = function(fiber, findNodeHandle) {
@@ -14803,7 +15562,7 @@ var getInspectorDataForViewTag = void 0;
   var createHierarchy = function(fiberHierarchy) {
     return fiberHierarchy.map(function(fiber) {
       return {
-        name: getComponentName(fiber),
+        name: getComponentName(fiber.type),
         getInspectorData: function(findNodeHandle) {
           return {
             measure: function(callback) {
@@ -14827,7 +15586,7 @@ var getInspectorDataForViewTag = void 0;
     if (!closestInstance) {
       return {
         hierarchy: [],
-        props: emptyObject,
+        props: emptyObject$2,
         selection: null,
         source: null
       };
@@ -14850,7 +15609,9 @@ var getInspectorDataForViewTag = void 0;
   };
 }
 
+// TODO: direct imports like some-package/src/* are bad. Fix me.
 // Module provided by RN:
+var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 var findHostInstance = findHostInstance$1;
 
 function findNodeHandle(componentOrHandle) {
@@ -14858,14 +15619,14 @@ function findNodeHandle(componentOrHandle) {
     var owner = ReactCurrentOwner.current;
     if (owner !== null && owner.stateNode !== null) {
       !owner.stateNode._warnedAboutRefsInRender
-        ? warning(
+        ? warningWithoutStack$1(
             false,
             "%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.",
-            getComponentName(owner) || "A component"
+            getComponentName(owner.type) || "A component"
           )
         : void 0;
 
@@ -14903,7 +15664,7 @@ function computeComponentStackForErrorReporting(reactTag) {
   if (!fiber) {
     return "";
   }
-  return getStackAddendumByWorkInProgressFiber(fiber);
+  return getStackByFiberInDevAndProd(fiber);
 }
 
 var roots = new Map();
diff --git a/Libraries/Renderer/oss/ReactNativeRenderer-prod.js b/Libraries/Renderer/oss/ReactNativeRenderer-prod.js
index 24da20e3b..80d35730f 100644
--- a/Libraries/Renderer/oss/ReactNativeRenderer-prod.js
+++ b/Libraries/Renderer/oss/ReactNativeRenderer-prod.js
@@ -12,16 +12,35 @@
 
 "use strict";
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant"),
-  ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
+var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
   UIManager = require("UIManager"),
   RCTEventEmitter = require("RCTEventEmitter"),
   React = require("react"),
-  emptyObject = require("fbjs/lib/emptyObject"),
   deepDiffer = require("deepDiffer"),
   flattenStyle = require("flattenStyle"),
   TextInputState = require("TextInputState"),
   ExceptionsManager = require("ExceptionsManager");
+function invariant(condition, format, a, b, c, d, e, f) {
+  if (!condition) {
+    condition = void 0;
+    if (void 0 === format)
+      condition = Error(
+        "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+      );
+    else {
+      var args = [a, b, c, d, e, f],
+        argIndex = 0;
+      condition = Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      condition.name = "Invariant Violation";
+    }
+    condition.framesToPop = 1;
+    throw condition;
+  }
+}
 function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = !1;
   this._caughtError = null;
@@ -347,9 +366,6 @@ function accumulateDirectDispatchesSingle(event) {
     }
   }
 }
-var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(
-  " "
-);
 function functionThatReturnsTrue() {
   return !0;
 }
@@ -407,12 +423,9 @@ Object.assign(SyntheticEvent.prototype, {
     var Interface = this.constructor.Interface,
       propName;
     for (propName in Interface) this[propName] = null;
-    for (
-      Interface = 0;
-      Interface < shouldBeReleasedProperties.length;
-      Interface++
-    )
-      this[shouldBeReleasedProperties[Interface]] = null;
+    this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+    this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+    this._dispatchInstances = this._dispatchListeners = null;
   }
 });
 SyntheticEvent.Interface = {
@@ -458,7 +471,7 @@ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
 function releasePooledEvent(event) {
   invariant(
     event instanceof this,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   10 > this.eventPool.length && this.eventPool.push(event);
@@ -615,7 +628,9 @@ function accumulate(current, next) {
     ? next
     : Array.isArray(current)
       ? current.concat(next)
-      : Array.isArray(next) ? [current].concat(next) : [current, next];
+      : Array.isArray(next)
+        ? [current].concat(next)
+        : [current, next];
 }
 var responderInst = null,
   trackedTouchCount = 0;
@@ -881,7 +896,9 @@ var eventTypes$1 = {
           ? eventTypes$1.responderStart
           : targetInst
             ? eventTypes$1.responderMove
-            : depthA ? eventTypes$1.responderEnd : null)
+            : depthA
+              ? eventTypes$1.responderEnd
+              : null)
       )
         (JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(
           JSCompiler_temp$jscomp$0,
@@ -935,7 +952,9 @@ var eventTypes$1 = {
       if (
         (topLevelType = JSCompiler_temp$jscomp$0
           ? eventTypes$1.responderTerminate
-          : topLevelType ? eventTypes$1.responderRelease : null)
+          : topLevelType
+            ? eventTypes$1.responderRelease
+            : null)
       )
         (nativeEvent = ResponderSyntheticEvent.getPooled(
           topLevelType,
@@ -1145,8 +1164,8 @@ ResponderEventPlugin.injection.injectGlobalResponderHandler({
       : UIManager.clearJSResponder();
   }
 });
-var ReactCurrentOwner =
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
+var ReactSharedInternals =
+    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
   hasSymbol = "function" === typeof Symbol && Symbol.for,
   REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103,
   REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106,
@@ -1157,7 +1176,7 @@ var ReactCurrentOwner =
   REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110,
   REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111,
   REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112,
-  REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 60113,
+  REACT_PLACEHOLDER_TYPE = hasSymbol ? Symbol.for("react.placeholder") : 60113,
   MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "undefined" === typeof maybeIterable)
@@ -1167,34 +1186,35 @@ function getIteratorFn(maybeIterable) {
     maybeIterable["@@iterator"];
   return "function" === typeof maybeIterable ? maybeIterable : null;
 }
-function getComponentName(fiber) {
-  var type = fiber.type;
-  if ("function" === typeof type) return type.displayName || type.name;
+function getComponentName(type) {
+  if (null == type) return null;
+  if ("function" === typeof type) return type.displayName || type.name || null;
   if ("string" === typeof type) return type;
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if ("object" === typeof type && null !== type)
+  if ("object" === typeof type)
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
         return (
-          (fiber = type.render.displayName || type.render.name || ""),
-          "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef"
+          (type = type.render),
+          (type = type.displayName || type.name || ""),
+          "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"
         );
     }
   return null;
@@ -1323,7 +1343,7 @@ function findCurrentHostFiberWithNoPortals(parent) {
   }
   return null;
 }
-var emptyObject$1 = {},
+var emptyObject = {},
   removedKeys = null,
   removedKeyCount = 0;
 function restoreDeletedValuesInNestedArray(
@@ -1423,7 +1443,7 @@ function addNestedProperty(updatePayload, nextProp, validAttributes) {
   if (!Array.isArray(nextProp))
     return diffProperties(
       updatePayload,
-      emptyObject$1,
+      emptyObject,
       nextProp,
       validAttributes
     );
@@ -1441,7 +1461,7 @@ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
     return diffProperties(
       updatePayload,
       prevProp,
-      emptyObject$1,
+      emptyObject,
       validAttributes
     );
   for (var i = 0; i < prevProp.length; i++)
@@ -1597,7 +1617,7 @@ var ReactNativeFiberHostComponent = (function() {
     ) {
       nativeProps = diffProperties(
         null,
-        emptyObject$1,
+        emptyObject,
         nativeProps,
         this.viewConfig.validAttributes
       );
@@ -1638,7 +1658,8 @@ function shim$1() {
     "The current renderer does not support hyration. This error is likely caused by a bug in React. Please file an issue."
   );
 }
-var nextReactTag = 3;
+var UPDATE_SIGNAL = {},
+  nextReactTag = 3;
 function allocateTag() {
   var tag = nextReactTag;
   1 === tag % 10 && (tag += 2);
@@ -1659,7 +1680,7 @@ function finalizeInitialChildren(parentInstance) {
   UIManager.setChildren(parentInstance._nativeTag, nativeTags);
   return !1;
 }
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   do {
     a: switch (workInProgress.tag) {
@@ -1667,11 +1688,12 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
       case 1:
       case 2:
       case 5:
+      case 11:
         var owner = workInProgress._debugOwner,
           source = workInProgress._debugSource;
-        var JSCompiler_inline_result = getComponentName(workInProgress);
+        var JSCompiler_inline_result = getComponentName(workInProgress.type);
         var ownerName = null;
-        owner && (ownerName = getComponentName(owner));
+        owner && (ownerName = getComponentName(owner.type));
         owner = source;
         JSCompiler_inline_result =
           "\n    in " +
@@ -1682,7 +1704,9 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
               ":" +
               owner.lineNumber +
               ")"
-            : ownerName ? " (created by " + ownerName + ")" : "");
+            : ownerName
+              ? " (created by " + ownerName + ")"
+              : "");
         break a;
       default:
         JSCompiler_inline_result = "";
@@ -1695,9 +1719,6 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
 new Set();
 var valueStack = [],
   index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
-}
 function pop(cursor) {
   0 > index ||
     ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
@@ -1707,9 +1728,10 @@ function push(cursor, value) {
   valueStack[index] = cursor.current;
   cursor.current = value;
 }
-var contextStackCursor = createCursor(emptyObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyObject;
+var emptyContextObject = {},
+  contextStackCursor = { current: emptyContextObject },
+  didPerformWorkStackCursor = { current: !1 },
+  previousContext = emptyContextObject;
 function getUnmaskedContext(workInProgress) {
   return isContextProvider(workInProgress)
     ? previousContext
@@ -1717,7 +1739,7 @@ function getUnmaskedContext(workInProgress) {
 }
 function getMaskedContext(workInProgress, unmaskedContext) {
   var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyObject;
+  if (!contextTypes) return emptyContextObject;
   var instance = workInProgress.stateNode;
   if (
     instance &&
@@ -1746,15 +1768,16 @@ function popTopLevelContextObject(fiber) {
 }
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "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(fiber, parentContext) {
-  var instance = fiber.stateNode,
-    childContextTypes = fiber.type.childContextTypes;
+  var instance = fiber.stateNode;
+  fiber = fiber.type;
+  var childContextTypes = fiber.childContextTypes;
   if ("function" !== typeof instance.getChildContext) return parentContext;
   instance = instance.getChildContext();
   for (var contextKey in instance)
@@ -1771,7 +1794,7 @@ function pushContextProvider(workInProgress) {
   var instance = workInProgress.stateNode;
   instance =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
   previousContext = contextStackCursor.current;
   push(contextStackCursor, instance, workInProgress);
   push(
@@ -1796,6 +1819,30 @@ function invalidateContextProvider(workInProgress, didChange) {
   } else pop(didPerformWorkStackCursor, workInProgress);
   push(didPerformWorkStackCursor, didChange, workInProgress);
 }
+var onCommitFiberRoot = null,
+  onCommitFiberUnmount = null;
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {}
+  };
+}
+function injectInternals(internals) {
+  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled || !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 FiberNode(tag, pendingProps, key, mode) {
   this.tag = tag;
   this.key = key;
@@ -1803,11 +1850,11 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.index = 0;
   this.ref = null;
   this.pendingProps = pendingProps;
-  this.memoizedState = this.updateQueue = this.memoizedProps = null;
+  this.firstContextDependency = this.memoizedState = this.updateQueue = this.memoizedProps = null;
   this.mode = mode;
   this.effectTag = 0;
   this.lastEffect = this.firstEffect = this.nextEffect = null;
-  this.expirationTime = 0;
+  this.childExpirationTime = this.expirationTime = 0;
   this.alternate = null;
 }
 function createWorkInProgress(current, pendingProps, expirationTime) {
@@ -1828,11 +1875,16 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
       (workInProgress.nextEffect = null),
       (workInProgress.firstEffect = null),
       (workInProgress.lastEffect = null));
-  workInProgress.expirationTime = expirationTime;
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  workInProgress.expirationTime =
+    pendingProps !== current.pendingProps
+      ? expirationTime
+      : current.expirationTime;
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
   workInProgress.sibling = current.sibling;
   workInProgress.index = current.index;
   workInProgress.ref = current.ref;
@@ -1869,15 +1921,14 @@ function createFiberFromElement(element, mode, expirationTime) {
           (type.expirationTime = expirationTime),
           type
         );
-      case REACT_TIMEOUT_TYPE:
+      case REACT_PLACEHOLDER_TYPE:
         fiberTag = 16;
-        mode |= 2;
         break;
       default:
         a: {
-          switch ("object" === typeof type && null !== type
-            ? type.$$typeof
-            : null) {
+          switch (
+            "object" === typeof type && null !== type ? type.$$typeof : null
+          ) {
             case REACT_PROVIDER_TYPE:
               fiberTag = 13;
               break a;
@@ -1942,6 +1993,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
     didError: !1,
     pendingCommitExpirationTime: 0,
     finishedWork: null,
+    timeoutHandle: -1,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -1952,36 +2004,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   };
   return (isAsync.stateNode = containerInfo);
 }
-var onCommitFiberRoot = null,
-  onCommitFiberUnmount = null;
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {}
-  };
-}
-function injectInternals(internals) {
-  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled || !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(root) {
-  "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
-}
-function onCommitUnmount(fiber) {
-  "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
-}
 function markPendingPriorityLevel(root, expirationTime) {
   root.didError = !1;
   var earliestPendingTime = root.earliestPendingTime;
@@ -1991,30 +2013,30 @@ function markPendingPriorityLevel(root, expirationTime) {
       ? (root.earliestPendingTime = expirationTime)
       : root.latestPendingTime < expirationTime &&
         (root.latestPendingTime = expirationTime);
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
-function findNextPendingPriorityLevel(root) {
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
   var earliestSuspendedTime = root.earliestSuspendedTime,
-    earliestPendingTime = root.earliestPendingTime;
-  if (0 === earliestSuspendedTime)
-    var nextExpirationTimeToWorkOn = (earliestSuspendedTime = earliestPendingTime);
-  else
-    0 !== earliestPendingTime
-      ? ((nextExpirationTimeToWorkOn = earliestPendingTime),
-        (earliestSuspendedTime =
-          earliestSuspendedTime < earliestPendingTime
-            ? earliestSuspendedTime
-            : earliestPendingTime))
-      : (nextExpirationTimeToWorkOn = earliestSuspendedTime =
-          root.latestPingedTime);
-  root.didError && (earliestSuspendedTime = 1);
-  root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
-  root.expirationTime = earliestSuspendedTime;
+    latestSuspendedTime = root.latestSuspendedTime,
+    earliestPendingTime = root.earliestPendingTime,
+    latestPingedTime = root.latestPingedTime;
+  earliestPendingTime =
+    0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+  0 === earliestPendingTime &&
+    (0 === completedExpirationTime ||
+      latestSuspendedTime > completedExpirationTime) &&
+    (earliestPendingTime = latestSuspendedTime);
+  completedExpirationTime = earliestPendingTime;
+  0 !== completedExpirationTime &&
+    0 !== earliestSuspendedTime &&
+    earliestSuspendedTime < completedExpirationTime &&
+    (completedExpirationTime = earliestSuspendedTime);
+  root.nextExpirationTimeToWorkOn = earliestPendingTime;
+  root.expirationTime = completedExpirationTime;
 }
 var hasForceUpdate = !1;
 function createUpdateQueue(baseState) {
   return {
-    expirationTime: 0,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -2028,7 +2050,6 @@ function createUpdateQueue(baseState) {
 }
 function cloneUpdateQueue(currentQueue) {
   return {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -2050,14 +2071,12 @@ function createUpdate(expirationTime) {
     nextEffect: null
   };
 }
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   null === queue.lastUpdate
     ? (queue.firstUpdate = queue.lastUpdate = update)
     : ((queue.lastUpdate.next = update), (queue.lastUpdate = update));
-  if (0 === queue.expirationTime || queue.expirationTime > expirationTime)
-    queue.expirationTime = expirationTime;
 }
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   var alternate = fiber.alternate;
   if (null === alternate) {
     var queue1 = fiber.updateQueue;
@@ -2079,14 +2098,13 @@ function enqueueUpdate(fiber, update, expirationTime) {
         : null === queue2 &&
           (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
   null === queue2 || queue1 === queue2
-    ? appendUpdateToQueue(queue1, update, expirationTime)
+    ? appendUpdateToQueue(queue1, update)
     : null === queue1.lastUpdate || null === queue2.lastUpdate
-      ? (appendUpdateToQueue(queue1, update, expirationTime),
-        appendUpdateToQueue(queue2, update, expirationTime))
-      : (appendUpdateToQueue(queue1, update, expirationTime),
-        (queue2.lastUpdate = update));
+      ? (appendUpdateToQueue(queue1, update),
+        appendUpdateToQueue(queue2, update))
+      : (appendUpdateToQueue(queue1, update), (queue2.lastUpdate = update));
 }
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   var workInProgressQueue = workInProgress.updateQueue;
   workInProgressQueue =
     null === workInProgressQueue
@@ -2098,11 +2116,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     ? (workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update)
     : ((workInProgressQueue.lastCapturedUpdate.next = update),
       (workInProgressQueue.lastCapturedUpdate = update));
-  if (
-    0 === workInProgressQueue.expirationTime ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  )
-    workInProgressQueue.expirationTime = renderExpirationTime;
 }
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
   var current = workInProgress.alternate;
@@ -2150,87 +2163,83 @@ function processUpdateQueue(
   renderExpirationTime
 ) {
   hasForceUpdate = !1;
-  if (
-    !(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)
-  ) {
-    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
-    for (
-      var newBaseState = queue.baseState,
-        newFirstUpdate = null,
-        newExpirationTime = 0,
-        update = queue.firstUpdate,
-        resultState = newBaseState;
-      null !== update;
+  queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+  for (
+    var newBaseState = queue.baseState,
+      newFirstUpdate = null,
+      newExpirationTime = 0,
+      update = queue.firstUpdate,
+      resultState = newBaseState;
+    null !== update;
 
-    ) {
-      var updateExpirationTime = update.expirationTime;
-      if (updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === newFirstUpdate &&
-            ((newFirstUpdate = update), (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > updateExpirationTime)
-        )
-          newExpirationTime = updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastEffect
-              ? (queue.firstEffect = queue.lastEffect = update)
-              : ((queue.lastEffect.nextEffect = update),
-                (queue.lastEffect = update)));
-      update = update.next;
-    }
-    updateExpirationTime = null;
-    for (update = queue.firstCapturedUpdate; null !== update; ) {
-      var _updateExpirationTime = update.expirationTime;
-      if (_updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === updateExpirationTime &&
-            ((updateExpirationTime = update),
-            null === newFirstUpdate && (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
-        )
-          newExpirationTime = _updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastCapturedEffect
-              ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
-              : ((queue.lastCapturedEffect.nextEffect = update),
-                (queue.lastCapturedEffect = update)));
-      update = update.next;
-    }
-    null === newFirstUpdate && (queue.lastUpdate = null);
-    null === updateExpirationTime
-      ? (queue.lastCapturedUpdate = null)
-      : (workInProgress.effectTag |= 32);
-    null === newFirstUpdate &&
-      null === updateExpirationTime &&
-      (newBaseState = resultState);
-    queue.baseState = newBaseState;
-    queue.firstUpdate = newFirstUpdate;
-    queue.firstCapturedUpdate = updateExpirationTime;
-    queue.expirationTime = newExpirationTime;
-    workInProgress.memoizedState = resultState;
+  ) {
+    var updateExpirationTime = update.expirationTime;
+    if (updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === newFirstUpdate &&
+          ((newFirstUpdate = update), (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > updateExpirationTime)
+      )
+        newExpirationTime = updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastEffect
+            ? (queue.firstEffect = queue.lastEffect = update)
+            : ((queue.lastEffect.nextEffect = update),
+              (queue.lastEffect = update)));
+    update = update.next;
   }
+  updateExpirationTime = null;
+  for (update = queue.firstCapturedUpdate; null !== update; ) {
+    var _updateExpirationTime = update.expirationTime;
+    if (_updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === updateExpirationTime &&
+          ((updateExpirationTime = update),
+          null === newFirstUpdate && (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
+      )
+        newExpirationTime = _updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastCapturedEffect
+            ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
+            : ((queue.lastCapturedEffect.nextEffect = update),
+              (queue.lastCapturedEffect = update)));
+    update = update.next;
+  }
+  null === newFirstUpdate && (queue.lastUpdate = null);
+  null === updateExpirationTime
+    ? (queue.lastCapturedUpdate = null)
+    : (workInProgress.effectTag |= 32);
+  null === newFirstUpdate &&
+    null === updateExpirationTime &&
+    (newBaseState = resultState);
+  queue.baseState = newBaseState;
+  queue.firstUpdate = newFirstUpdate;
+  queue.firstCapturedUpdate = updateExpirationTime;
+  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.memoizedState = resultState;
 }
 function callCallback(callback, context) {
   invariant(
@@ -2272,34 +2281,153 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
-var providerCursor = createCursor(null),
-  valueCursor = createCursor(null),
-  changedBitsCursor = createCursor(0);
+var valueCursor = { current: null },
+  changedBitsCursor = { current: 0 },
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastContextWithAllBitsObserved = null;
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
   push(changedBitsCursor, context._changedBits, providerFiber);
   push(valueCursor, context._currentValue, providerFiber);
-  push(providerCursor, providerFiber, providerFiber);
   context._currentValue = providerFiber.pendingProps.value;
   context._changedBits = providerFiber.stateNode;
 }
 function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current,
     currentValue = valueCursor.current;
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
   providerFiber = providerFiber.type._context;
   providerFiber._currentValue = currentValue;
   providerFiber._changedBits = changedBits;
 }
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  null !== fiber && (fiber.return = workInProgress);
+  for (; null !== fiber; ) {
+    var dependency = fiber.firstContextDependency;
+    if (null !== dependency) {
+      do {
+        if (
+          dependency.context === context &&
+          0 !== (dependency.observedBits & changedBits)
+        ) {
+          if (
+            0 === fiber.expirationTime ||
+            fiber.expirationTime > renderExpirationTime
+          )
+            fiber.expirationTime = renderExpirationTime;
+          var nextFiber = fiber.alternate;
+          null !== nextFiber &&
+            (0 === nextFiber.expirationTime ||
+              nextFiber.expirationTime > renderExpirationTime) &&
+            (nextFiber.expirationTime = renderExpirationTime);
+          for (var node = fiber.return; null !== node; ) {
+            nextFiber = node.alternate;
+            if (
+              0 === node.childExpirationTime ||
+              node.childExpirationTime > renderExpirationTime
+            )
+              (node.childExpirationTime = renderExpirationTime),
+                null !== nextFiber &&
+                  (0 === nextFiber.childExpirationTime ||
+                    nextFiber.childExpirationTime > renderExpirationTime) &&
+                  (nextFiber.childExpirationTime = renderExpirationTime);
+            else if (
+              null !== nextFiber &&
+              (0 === nextFiber.childExpirationTime ||
+                nextFiber.childExpirationTime > renderExpirationTime)
+            )
+              nextFiber.childExpirationTime = renderExpirationTime;
+            else break;
+            node = node.return;
+          }
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        dependency = dependency.next;
+      } while (null !== dependency);
+    } else
+      nextFiber =
+        13 === fiber.tag
+          ? fiber.type === workInProgress.type
+            ? null
+            : fiber.child
+          : fiber.child;
+    if (null !== nextFiber) nextFiber.return = fiber;
+    else
+      for (nextFiber = fiber; null !== nextFiber; ) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+    fiber = nextFiber;
+  }
+}
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextWithAllBitsObserved = lastContextDependency = null;
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (null !== firstContextDependency) {
+    workInProgress.firstContextDependency = null;
+    var hasPendingContext = !1;
+    do {
+      var _context = firstContextDependency.context,
+        changedBits = _context._changedBits;
+      0 !== changedBits &&
+        (propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        ),
+        0 !== (changedBits & firstContextDependency.observedBits) &&
+          (hasPendingContext = !0));
+      firstContextDependency = firstContextDependency.next;
+    } while (null !== firstContextDependency);
+    return hasPendingContext;
+  }
+  return !1;
+}
+function readContext(context, observedBits) {
+  if (
+    lastContextWithAllBitsObserved !== context &&
+    !1 !== observedBits &&
+    0 !== observedBits
+  ) {
+    if ("number" !== typeof observedBits || 1073741823 === observedBits)
+      (lastContextWithAllBitsObserved = context), (observedBits = 1073741823);
+    observedBits = { context: context, observedBits: observedBits, next: null };
+    null === lastContextDependency
+      ? (invariant(
+          null !== currentlyRenderingFiber,
+          "Context.unstable_read(): Context can only be read while React is rendering, e.g. inside the render method or getDerivedStateFromProps."
+        ),
+        (currentlyRenderingFiber.firstContextDependency = lastContextDependency = observedBits))
+      : (lastContextDependency = lastContextDependency.next = observedBits);
+  }
+  return context._currentValue;
+}
 var NO_CONTEXT = {},
-  contextStackCursor$1 = createCursor(NO_CONTEXT),
-  contextFiberStackCursor = createCursor(NO_CONTEXT),
-  rootInstanceStackCursor = createCursor(NO_CONTEXT);
+  contextStackCursor$1 = { current: NO_CONTEXT },
+  contextFiberStackCursor = { current: NO_CONTEXT },
+  rootInstanceStackCursor = { current: NO_CONTEXT };
 function requiredContext(c) {
   invariant(
     c !== NO_CONTEXT,
@@ -2319,6 +2447,24 @@ function popHostContainer(fiber) {
   pop(contextFiberStackCursor, fiber);
   pop(rootInstanceStackCursor, fiber);
 }
+function pushHostContext(fiber) {
+  requiredContext(rootInstanceStackCursor.current);
+  var context = requiredContext(contextStackCursor$1.current);
+  var nextContext = fiber.type;
+  nextContext =
+    "AndroidTextInput" === nextContext ||
+    "RCTMultilineTextInputView" === nextContext ||
+    "RCTSinglelineTextInputView" === nextContext ||
+    "RCTText" === nextContext ||
+    "RCTVirtualText" === nextContext;
+  nextContext =
+    context.isInAParentText !== nextContext
+      ? { isInAParentText: nextContext }
+      : context;
+  context !== nextContext &&
+    (push(contextFiberStackCursor, fiber, fiber),
+    push(contextStackCursor$1, nextContext, fiber));
+}
 function popHostContext(fiber) {
   contextFiberStackCursor.current === fiber &&
     (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
@@ -2347,6 +2493,7 @@ function shallowEqual(objA, objB) {
       return !1;
   return !0;
 }
+var emptyRefsObject = new React.Component().refs;
 function applyDerivedStateFromProps(
   workInProgress,
   getDerivedStateFromProps,
@@ -2359,10 +2506,10 @@ function applyDerivedStateFromProps(
       ? prevState
       : Object.assign({}, prevState, getDerivedStateFromProps);
   workInProgress.memoizedState = prevState;
-  workInProgress = workInProgress.updateQueue;
-  null !== workInProgress &&
+  getDerivedStateFromProps = workInProgress.updateQueue;
+  null !== getDerivedStateFromProps &&
     0 === workInProgress.expirationTime &&
-    (workInProgress.baseState = prevState);
+    (getDerivedStateFromProps.baseState = prevState);
 }
 var classComponentUpdater = {
   isMounted: function(component) {
@@ -2372,33 +2519,33 @@ var classComponentUpdater = {
   },
   enqueueSetState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 1;
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 2;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   }
 };
@@ -2408,12 +2555,12 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   workInProgress = workInProgress.type;
   return "function" === typeof instance.shouldComponentUpdate
-    ? instance.shouldComponentUpdate(newProps, newState, newContext)
+    ? instance.shouldComponentUpdate(newProps, newState, nextLegacyContext)
     : workInProgress.prototype && workInProgress.prototype.isPureReactComponent
       ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
       : !0;
@@ -2422,13 +2569,13 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   workInProgress = instance.state;
   "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   instance.state !== workInProgress &&
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
@@ -2439,7 +2586,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     unmaskedContext = getUnmaskedContext(workInProgress);
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
   unmaskedContext = workInProgress.updateQueue;
   null !== unmaskedContext &&
@@ -2451,7 +2598,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
       renderExpirationTime
     ),
     (instance.state = workInProgress.memoizedState));
-  unmaskedContext = workInProgress.type.getDerivedStateFromProps;
+  unmaskedContext = ctor.getDerivedStateFromProps;
   "function" === typeof unmaskedContext &&
     (applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
     (instance.state = workInProgress.memoizedState));
@@ -2480,7 +2627,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     (workInProgress.effectTag |= 4);
 }
 var isArray$1 = Array.isArray;
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   returnFiber = element.ref;
   if (
     null !== returnFiber &&
@@ -2503,18 +2650,19 @@ function coerceRef(returnFiber, current, element) {
       );
       var stringRef = "" + returnFiber;
       if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
+        null !== current$$1 &&
+        null !== current$$1.ref &&
+        "function" === typeof current$$1.ref &&
+        current$$1.ref._stringRef === stringRef
       )
-        return current.ref;
-      current = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        return current$$1.ref;
+      current$$1 = function(value) {
+        var refs = inst.refs;
+        refs === emptyRefsObject && (refs = inst.refs = {});
         null === value ? delete refs[stringRef] : (refs[stringRef] = value);
       };
-      current._stringRef = stringRef;
-      return current;
+      current$$1._stringRef = stringRef;
+      return current$$1;
     }
     invariant(
       "string" === typeof returnFiber,
@@ -2592,26 +2740,31 @@ function ChildReconciler(shouldTrackSideEffects) {
       (newFiber.effectTag = 2);
     return newFiber;
   }
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (null === current || 6 !== current.tag)
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (null === current$$1 || 6 !== current$$1.tag)
       return (
-        (current = createFiberFromText(
+        (current$$1 = createFiberFromText(
           textContent,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, textContent, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, textContent, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (null !== current && current.type === element.type)
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (null !== current$$1 && current$$1.type === element.type)
       return (
-        (expirationTime = useFiber(current, element.props, expirationTime)),
-        (expirationTime.ref = coerceRef(returnFiber, current, element)),
+        (expirationTime = useFiber(current$$1, element.props, expirationTime)),
+        (expirationTime.ref = coerceRef(returnFiber, current$$1, element)),
         (expirationTime.return = returnFiber),
         expirationTime
       );
@@ -2620,45 +2773,51 @@ function ChildReconciler(shouldTrackSideEffects) {
       returnFiber.mode,
       expirationTime
     );
-    expirationTime.ref = coerceRef(returnFiber, current, element);
+    expirationTime.ref = coerceRef(returnFiber, current$$1, element);
     expirationTime.return = returnFiber;
     return expirationTime;
   }
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      null === current$$1 ||
+      4 !== current$$1.tag ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     )
       return (
-        (current = createFiberFromPortal(
+        (current$$1 = createFiberFromPortal(
           portal,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, portal.children || [], expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (null === current || 10 !== current.tag)
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (null === current$$1 || 10 !== current$$1.tag)
       return (
-        (current = createFiberFromFragment(
+        (current$$1 = createFiberFromFragment(
           fragment,
           returnFiber.mode,
           expirationTime,
           key
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, fragment, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, fragment, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
   function createChild(returnFiber, newChild, expirationTime) {
     if ("string" === typeof newChild || "number" === typeof newChild)
@@ -3224,22 +3383,15 @@ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
         (hydrationParentFiber = fiber$jscomp$0);
   }
 }
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-function reconcileChildrenAtExpirationTime(
-  current,
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
   workInProgress.child =
-    null === current
+    null === current$$1
       ? mountChildFibers(
           workInProgress,
           null,
@@ -3248,47 +3400,47 @@ function reconcileChildrenAtExpirationTime(
         )
       : reconcileChildFibers(
           workInProgress,
-          current.child,
+          current$$1.child,
           nextChildren,
           renderExpirationTime
         );
 }
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
+    (null === current$$1 && null !== ref) ||
+    (null !== current$$1 && current$$1.ref !== ref)
   )
     workInProgress.effectTag |= 128;
 }
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
   var didCaptureError = 0 !== (workInProgress.effectTag & 64);
   if (!shouldUpdate && !didCaptureError)
     return (
       hasContext && invalidateContextProvider(workInProgress, !1),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
+      bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      )
     );
   shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   var nextChildren = didCaptureError ? null : shouldUpdate.render();
   workInProgress.effectTag |= 1;
-  didCaptureError &&
-    (reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    ),
+  null !== current$$1 &&
+    didCaptureError &&
+    (reconcileChildren(current$$1, workInProgress, null, renderExpirationTime),
     (workInProgress.child = null));
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -3310,164 +3462,57 @@ function pushHostRootContext(workInProgress) {
       pushTopLevelContextObject(workInProgress, root.context, !1);
   pushHostContainer(workInProgress, root.containerInfo);
 }
-function propagateContextChange(
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  null !== fiber && (fiber.return = workInProgress);
-  for (; null !== fiber; ) {
-    switch (fiber.tag) {
-      case 12:
-        var nextFiber = fiber.stateNode | 0;
-        if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
-          for (nextFiber = fiber; null !== nextFiber; ) {
-            var alternate = nextFiber.alternate;
-            if (
-              0 === nextFiber.expirationTime ||
-              nextFiber.expirationTime > renderExpirationTime
-            )
-              (nextFiber.expirationTime = renderExpirationTime),
-                null !== alternate &&
-                  (0 === alternate.expirationTime ||
-                    alternate.expirationTime > renderExpirationTime) &&
-                  (alternate.expirationTime = renderExpirationTime);
-            else if (
-              null !== alternate &&
-              (0 === alternate.expirationTime ||
-                alternate.expirationTime > renderExpirationTime)
-            )
-              alternate.expirationTime = renderExpirationTime;
-            else break;
-            nextFiber = nextFiber.return;
-          }
-          nextFiber = null;
-        } else nextFiber = fiber.child;
-        break;
-      case 13:
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        nextFiber = fiber.child;
-    }
-    if (null !== nextFiber) nextFiber.return = fiber;
-    else
-      for (nextFiber = fiber; null !== nextFiber; ) {
-        if (nextFiber === workInProgress) {
-          nextFiber = null;
-          break;
-        }
-        fiber = nextFiber.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
-        }
-        nextFiber = nextFiber.return;
-      }
-    fiber = nextFiber;
-  }
-}
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
-  var context = workInProgress.type._context,
-    newProps = workInProgress.pendingProps,
-    oldProps = workInProgress.memoizedProps,
-    canBailOnProps = !0;
-  if (didPerformWorkStackCursor.current) canBailOnProps = !1;
-  else if (oldProps === newProps)
-    return (
-      (workInProgress.stateNode = 0),
-      pushProvider(workInProgress),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
-    );
-  var newValue = newProps.value;
-  workInProgress.memoizedProps = newProps;
-  if (null === oldProps) newValue = 1073741823;
-  else if (oldProps.value === newProps.value) {
-    if (oldProps.children === newProps.children && canBailOnProps)
-      return (
-        (workInProgress.stateNode = 0),
-        pushProvider(workInProgress),
-        bailoutOnAlreadyFinishedWork(current, workInProgress)
-      );
-    newValue = 0;
-  } else {
-    var oldValue = oldProps.value;
-    if (
-      (oldValue === newValue &&
-        (0 !== oldValue || 1 / oldValue === 1 / newValue)) ||
-      (oldValue !== oldValue && newValue !== newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-      newValue = 0;
-    } else if (
-      ((newValue =
-        "function" === typeof context._calculateChangedBits
-          ? context._calculateChangedBits(oldValue, newValue)
-          : 1073741823),
-      (newValue |= 0),
-      0 === newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-    } else
-      propagateContextChange(
-        workInProgress,
-        context,
-        newValue,
-        renderExpirationTime
-      );
-  }
-  workInProgress.stateNode = newValue;
-  pushProvider(workInProgress);
-  reconcileChildren(current, workInProgress, newProps.children);
-  return workInProgress.child;
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+  null !== current$$1 &&
+    (workInProgress.firstContextDependency = current$$1.firstContextDependency);
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (0 === childExpirationTime || childExpirationTime > renderExpirationTime)
+    return null;
   invariant(
-    null === current || workInProgress.child === current.child,
+    null === current$$1 || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
   if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    var newChild = createWorkInProgress(
-      current,
-      current.pendingProps,
-      current.expirationTime
+    current$$1 = workInProgress.child;
+    renderExpirationTime = createWorkInProgress(
+      current$$1,
+      current$$1.pendingProps,
+      current$$1.expirationTime
     );
-    workInProgress.child = newChild;
-    for (newChild.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (newChild = newChild.sibling = createWorkInProgress(
-          current,
-          current.pendingProps,
-          current.expirationTime
+    workInProgress.child = renderExpirationTime;
+    for (
+      renderExpirationTime.return = workInProgress;
+      null !== current$$1.sibling;
+
+    )
+      (current$$1 = current$$1.sibling),
+        (renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(
+          current$$1,
+          current$$1.pendingProps,
+          current$$1.expirationTime
         )),
-        (newChild.return = workInProgress);
-    newChild.sibling = null;
+        (renderExpirationTime.return = workInProgress);
+    renderExpirationTime.sibling = null;
   }
   return workInProgress.child;
 }
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    0 === workInProgress.expirationTime ||
-    workInProgress.expirationTime > renderExpirationTime
+    !didPerformWorkStackCursor.current &&
+    (0 === updateExpirationTime || updateExpirationTime > renderExpirationTime)
   ) {
     switch (workInProgress.tag) {
       case 3:
         pushHostRootContext(workInProgress);
         break;
+      case 5:
+        pushHostContext(workInProgress);
+        break;
       case 2:
         pushContextProvider(workInProgress);
         break;
@@ -3478,21 +3523,27 @@ function beginWork(current, workInProgress, renderExpirationTime) {
         );
         break;
       case 13:
-        pushProvider(workInProgress);
+        (workInProgress.stateNode = 0), pushProvider(workInProgress);
     }
-    return null;
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
+  workInProgress.expirationTime = 0;
   switch (workInProgress.tag) {
     case 0:
       invariant(
-        null === current,
+        null === current$$1,
         "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue."
       );
-      var fn = workInProgress.type,
-        props = workInProgress.pendingProps,
-        unmaskedContext = getUnmaskedContext(workInProgress);
+      var fn = workInProgress.type;
+      updateExpirationTime = workInProgress.pendingProps;
+      var unmaskedContext = getUnmaskedContext(workInProgress);
       unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
-      fn = fn(props, unmaskedContext);
+      prepareToReadContext(workInProgress, renderExpirationTime);
+      fn = fn(updateExpirationTime, unmaskedContext);
       workInProgress.effectTag |= 1;
       "object" === typeof fn &&
       null !== fn &&
@@ -3504,45 +3555,52 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null !== fn.state && void 0 !== fn.state ? fn.state : null),
           (unmaskedContext = unmaskedContext.getDerivedStateFromProps),
           "function" === typeof unmaskedContext &&
-            applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
-          (props = pushContextProvider(workInProgress)),
+            applyDerivedStateFromProps(
+              workInProgress,
+              unmaskedContext,
+              updateExpirationTime
+            ),
+          (updateExpirationTime = pushContextProvider(workInProgress)),
           (fn.updater = classComponentUpdater),
           (workInProgress.stateNode = fn),
           (fn._reactInternalFiber = workInProgress),
           mountClassInstance(workInProgress, renderExpirationTime),
-          (current = finishClassComponent(
-            current,
+          (current$$1 = finishClassComponent(
+            current$$1,
             workInProgress,
             !0,
-            props,
+            updateExpirationTime,
             renderExpirationTime
           )))
         : ((workInProgress.tag = 1),
-          reconcileChildren(current, workInProgress, fn),
-          (workInProgress.memoizedProps = props),
-          (current = workInProgress.child));
-      return current;
+          reconcileChildren(
+            current$$1,
+            workInProgress,
+            fn,
+            renderExpirationTime
+          ),
+          (workInProgress.memoizedProps = updateExpirationTime),
+          (current$$1 = workInProgress.child));
+      return current$$1;
     case 1:
       return (
-        (props = workInProgress.type),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? ((fn = getUnmaskedContext(workInProgress)),
-            (fn = getMaskedContext(workInProgress, fn)),
-            (props = props(renderExpirationTime, fn)),
-            (workInProgress.effectTag |= 1),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (fn = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = getUnmaskedContext(workInProgress)),
+        (unmaskedContext = getMaskedContext(workInProgress, unmaskedContext)),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (fn = fn(updateExpirationTime, unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 2:
-      props = pushContextProvider(workInProgress);
-      if (null === current)
+      updateExpirationTime = pushContextProvider(workInProgress);
+      fn = prepareToReadContext(workInProgress, renderExpirationTime);
+      if (null === current$$1)
         if (null === workInProgress.stateNode) {
-          var props$jscomp$0 = workInProgress.pendingProps,
+          var props = workInProgress.pendingProps,
             ctor = workInProgress.type;
           fn = getUnmaskedContext(workInProgress);
           var needsContext =
@@ -3550,15 +3608,13 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null != workInProgress.type.contextTypes;
           unmaskedContext = needsContext
             ? getMaskedContext(workInProgress, fn)
-            : emptyObject;
-          props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
+            : emptyContextObject;
+          props = new ctor(props, unmaskedContext);
           workInProgress.memoizedState =
-            null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state
-              ? props$jscomp$0.state
-              : null;
-          props$jscomp$0.updater = classComponentUpdater;
-          workInProgress.stateNode = props$jscomp$0;
-          props$jscomp$0._reactInternalFiber = workInProgress;
+            null !== props.state && void 0 !== props.state ? props.state : null;
+          props.updater = classComponentUpdater;
+          workInProgress.stateNode = props;
+          props._reactInternalFiber = workInProgress;
           needsContext &&
             ((needsContext = workInProgress.stateNode),
             (needsContext.__reactInternalMemoizedUnmaskedChildContext = fn),
@@ -3566,122 +3622,46 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           mountClassInstance(workInProgress, renderExpirationTime);
           fn = !0;
         } else {
-          ctor = workInProgress.type;
-          fn = workInProgress.stateNode;
-          needsContext = workInProgress.memoizedProps;
-          unmaskedContext = workInProgress.pendingProps;
-          fn.props = needsContext;
-          var oldContext = fn.context;
-          props$jscomp$0 = getUnmaskedContext(workInProgress);
-          props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
-          var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-          (ctor =
+          var ctor$jscomp$0 = workInProgress.type;
+          unmaskedContext = workInProgress.stateNode;
+          props = workInProgress.memoizedProps;
+          needsContext = workInProgress.pendingProps;
+          unmaskedContext.props = props;
+          var oldContext = unmaskedContext.context;
+          ctor = getUnmaskedContext(workInProgress);
+          ctor = getMaskedContext(workInProgress, ctor);
+          var getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps;
+          (ctor$jscomp$0 =
             "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((needsContext !== unmaskedContext ||
-              oldContext !== props$jscomp$0) &&
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((props !== needsContext || oldContext !== ctor) &&
               callComponentWillReceiveProps(
                 workInProgress,
-                fn,
                 unmaskedContext,
-                props$jscomp$0
+                needsContext,
+                ctor
               ));
           hasForceUpdate = !1;
           var oldState = workInProgress.memoizedState;
-          oldContext = fn.state = oldState;
+          oldContext = unmaskedContext.state = oldState;
           var updateQueue = workInProgress.updateQueue;
           null !== updateQueue &&
             (processUpdateQueue(
               workInProgress,
               updateQueue,
+              needsContext,
               unmaskedContext,
-              fn,
               renderExpirationTime
             ),
             (oldContext = workInProgress.memoizedState));
-          needsContext !== unmaskedContext ||
+          props !== needsContext ||
           oldState !== oldContext ||
           didPerformWorkStackCursor.current ||
-          hasForceUpdate
-            ? ("function" === typeof getDerivedStateFromProps &&
-                (applyDerivedStateFromProps(
-                  workInProgress,
-                  getDerivedStateFromProps,
-                  unmaskedContext
-                ),
-                (oldContext = workInProgress.memoizedState)),
-              (needsContext =
-                hasForceUpdate ||
-                checkShouldComponentUpdate(
-                  workInProgress,
-                  needsContext,
-                  unmaskedContext,
-                  oldState,
-                  oldContext,
-                  props$jscomp$0
-                ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillMount &&
-                      "function" !== typeof fn.componentWillMount) ||
-                    ("function" === typeof fn.componentWillMount &&
-                      fn.componentWillMount(),
-                    "function" === typeof fn.UNSAFE_componentWillMount &&
-                      fn.UNSAFE_componentWillMount()),
-                  "function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4))
-                : ("function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4),
-                  (workInProgress.memoizedProps = unmaskedContext),
-                  (workInProgress.memoizedState = oldContext)),
-              (fn.props = unmaskedContext),
-              (fn.state = oldContext),
-              (fn.context = props$jscomp$0),
-              (fn = needsContext))
-            : ("function" === typeof fn.componentDidMount &&
-                (workInProgress.effectTag |= 4),
-              (fn = !1));
-        }
-      else
-        (ctor = workInProgress.type),
-          (fn = workInProgress.stateNode),
-          (unmaskedContext = workInProgress.memoizedProps),
-          (needsContext = workInProgress.pendingProps),
-          (fn.props = unmaskedContext),
-          (oldContext = fn.context),
-          (props$jscomp$0 = getUnmaskedContext(workInProgress)),
-          (props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0)),
-          (getDerivedStateFromProps = ctor.getDerivedStateFromProps),
-          (ctor =
-            "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((unmaskedContext !== needsContext ||
-              oldContext !== props$jscomp$0) &&
-              callComponentWillReceiveProps(
-                workInProgress,
-                fn,
-                needsContext,
-                props$jscomp$0
-              )),
-          (hasForceUpdate = !1),
-          (oldContext = workInProgress.memoizedState),
-          (oldState = fn.state = oldContext),
-          (updateQueue = workInProgress.updateQueue),
-          null !== updateQueue &&
-            (processUpdateQueue(
-              workInProgress,
-              updateQueue,
-              needsContext,
-              fn,
-              renderExpirationTime
-            ),
-            (oldState = workInProgress.memoizedState)),
-          unmaskedContext !== needsContext ||
-          oldContext !== oldState ||
-          didPerformWorkStackCursor.current ||
+          fn ||
           hasForceUpdate
             ? ("function" === typeof getDerivedStateFromProps &&
                 (applyDerivedStateFromProps(
@@ -3689,128 +3669,203 @@ function beginWork(current, workInProgress, renderExpirationTime) {
                   getDerivedStateFromProps,
                   needsContext
                 ),
-                (oldState = workInProgress.memoizedState)),
-              (getDerivedStateFromProps =
+                (oldContext = workInProgress.memoizedState)),
+              (fn =
                 hasForceUpdate ||
+                fn ||
                 checkShouldComponentUpdate(
                   workInProgress,
-                  unmaskedContext,
+                  props,
                   needsContext,
+                  oldState,
+                  oldContext,
+                  ctor
+                ))
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillMount) ||
+                    ("function" === typeof unmaskedContext.componentWillMount &&
+                      unmaskedContext.componentWillMount(),
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      unmaskedContext.UNSAFE_componentWillMount()),
+                  "function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4))
+                : ("function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4),
+                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedState = oldContext)),
+              (unmaskedContext.props = needsContext),
+              (unmaskedContext.state = oldContext),
+              (unmaskedContext.context = ctor))
+            : ("function" === typeof unmaskedContext.componentDidMount &&
+                (workInProgress.effectTag |= 4),
+              (fn = !1));
+        }
+      else
+        (ctor$jscomp$0 = workInProgress.type),
+          (unmaskedContext = workInProgress.stateNode),
+          (needsContext = workInProgress.memoizedProps),
+          (props = workInProgress.pendingProps),
+          (unmaskedContext.props = needsContext),
+          (oldContext = unmaskedContext.context),
+          (ctor = getUnmaskedContext(workInProgress)),
+          (ctor = getMaskedContext(workInProgress, ctor)),
+          (getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps),
+          (ctor$jscomp$0 =
+            "function" === typeof getDerivedStateFromProps ||
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((needsContext !== props || oldContext !== ctor) &&
+              callComponentWillReceiveProps(
+                workInProgress,
+                unmaskedContext,
+                props,
+                ctor
+              )),
+          (hasForceUpdate = !1),
+          (oldContext = workInProgress.memoizedState),
+          (oldState = unmaskedContext.state = oldContext),
+          (updateQueue = workInProgress.updateQueue),
+          null !== updateQueue &&
+            (processUpdateQueue(
+              workInProgress,
+              updateQueue,
+              props,
+              unmaskedContext,
+              renderExpirationTime
+            ),
+            (oldState = workInProgress.memoizedState)),
+          needsContext !== props ||
+          oldContext !== oldState ||
+          didPerformWorkStackCursor.current ||
+          fn ||
+          hasForceUpdate
+            ? ("function" === typeof getDerivedStateFromProps &&
+                (applyDerivedStateFromProps(
+                  workInProgress,
+                  getDerivedStateFromProps,
+                  props
+                ),
+                (oldState = workInProgress.memoizedState)),
+              (fn =
+                hasForceUpdate ||
+                fn ||
+                checkShouldComponentUpdate(
+                  workInProgress,
+                  needsContext,
+                  props,
                   oldContext,
                   oldState,
-                  props$jscomp$0
+                  ctor
                 ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillUpdate &&
-                      "function" !== typeof fn.componentWillUpdate) ||
-                    ("function" === typeof fn.componentWillUpdate &&
-                      fn.componentWillUpdate(
-                        needsContext,
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillUpdate) ||
+                    ("function" ===
+                      typeof unmaskedContext.componentWillUpdate &&
+                      unmaskedContext.componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       ),
-                    "function" === typeof fn.UNSAFE_componentWillUpdate &&
-                      fn.UNSAFE_componentWillUpdate(
-                        needsContext,
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      unmaskedContext.UNSAFE_componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       )),
-                  "function" === typeof fn.componentDidUpdate &&
+                  "function" === typeof unmaskedContext.componentDidUpdate &&
                     (workInProgress.effectTag |= 4),
-                  "function" === typeof fn.getSnapshotBeforeUpdate &&
+                  "function" ===
+                    typeof unmaskedContext.getSnapshotBeforeUpdate &&
                     (workInProgress.effectTag |= 256))
-                : ("function" !== typeof fn.componentDidUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 4),
-                  "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                  "function" !==
+                    typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 256),
-                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedProps = props),
                   (workInProgress.memoizedState = oldState)),
-              (fn.props = needsContext),
-              (fn.state = oldState),
-              (fn.context = props$jscomp$0),
-              (fn = getDerivedStateFromProps))
-            : ("function" !== typeof fn.componentDidUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              (unmaskedContext.props = props),
+              (unmaskedContext.state = oldState),
+              (unmaskedContext.context = ctor))
+            : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 4),
-              "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              "function" !== typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 256),
               (fn = !1));
       return finishClassComponent(
-        current,
+        current$$1,
         workInProgress,
         fn,
-        props,
+        updateExpirationTime,
         renderExpirationTime
       );
     case 3:
       return (
         pushHostRootContext(workInProgress),
-        (props = workInProgress.updateQueue),
-        null !== props
-          ? ((fn = workInProgress.memoizedState),
-            (fn = null !== fn ? fn.element : null),
-            processUpdateQueue(
+        (updateExpirationTime = workInProgress.updateQueue),
+        invariant(
+          null !== updateExpirationTime,
+          "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."
+        ),
+        (fn = workInProgress.memoizedState),
+        (fn = null !== fn ? fn.element : null),
+        processUpdateQueue(
+          workInProgress,
+          updateExpirationTime,
+          workInProgress.pendingProps,
+          null,
+          renderExpirationTime
+        ),
+        (updateExpirationTime = workInProgress.memoizedState.element),
+        updateExpirationTime === fn
+          ? (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
               workInProgress,
-              props,
-              workInProgress.pendingProps,
-              null,
+              renderExpirationTime
+            ))
+          : (reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
               renderExpirationTime
             ),
-            (renderExpirationTime = workInProgress.memoizedState.element),
-            renderExpirationTime === fn
-              ? (current = bailoutOnAlreadyFinishedWork(
-                  current,
-                  workInProgress
-                ))
-              : (reconcileChildren(
-                  current,
-                  workInProgress,
-                  renderExpirationTime
-                ),
-                (current = workInProgress.child)))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+            (current$$1 = workInProgress.child)),
+        current$$1
       );
     case 5:
       return (
-        requiredContext(rootInstanceStackCursor.current),
-        (renderExpirationTime = requiredContext(contextStackCursor$1.current)),
-        (props = workInProgress.type),
-        (props =
-          "AndroidTextInput" === props ||
-          "RCTMultilineTextInputView" === props ||
-          "RCTSinglelineTextInputView" === props ||
-          "RCTText" === props ||
-          "RCTVirtualText" === props),
-        (props =
-          renderExpirationTime.isInAParentText !== props
-            ? { isInAParentText: props }
-            : renderExpirationTime),
-        renderExpirationTime !== props &&
-          (push(contextFiberStackCursor, workInProgress, workInProgress),
-          push(contextStackCursor$1, props, workInProgress)),
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
-        (props = workInProgress.memoizedProps),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current || props !== renderExpirationTime
-          ? ((props = renderExpirationTime.children),
-            markRef(current, workInProgress),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        pushHostContext(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        markRef(current$$1, workInProgress),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        (current$$1 = workInProgress.child),
+        current$$1
       );
     case 6:
       return (
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
         (workInProgress.memoizedProps = workInProgress.pendingProps),
         null
       );
@@ -3822,113 +3877,181 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           workInProgress,
           workInProgress.stateNode.containerInfo
         ),
-        (props = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== props
-          ? (null === current
-              ? (workInProgress.child = reconcileChildFibers(
-                  workInProgress,
-                  null,
-                  props,
-                  renderExpirationTime
-                ))
-              : reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = props),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        null === current$$1
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              updateExpirationTime,
+              renderExpirationTime
+            ))
+          : reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
+              renderExpirationTime
+            ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 14:
       return (
-        (props = workInProgress.type.render),
-        (renderExpirationTime = workInProgress.pendingProps),
-        (fn = workInProgress.ref),
+        (fn = workInProgress.type.render),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = workInProgress.ref),
         didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime ||
-        fn !== (null !== current ? current.ref : null)
-          ? ((props = props(renderExpirationTime, fn)),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        workInProgress.memoizedProps !== updateExpirationTime ||
+        unmaskedContext !== (null !== current$$1 ? current$$1.ref : null)
+          ? ((fn = fn(updateExpirationTime, unmaskedContext)),
+            reconcileChildren(
+              current$$1,
+              workInProgress,
+              fn,
+              renderExpirationTime
+            ),
+            (workInProgress.memoizedProps = updateExpirationTime),
+            (current$$1 = workInProgress.child))
+          : (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            )),
+        current$$1
       );
     case 10:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 11:
       return (
-        (renderExpirationTime = workInProgress.pendingProps.children),
-        didPerformWorkStackCursor.current ||
-        (null !== renderExpirationTime &&
-          workInProgress.memoizedProps !== renderExpirationTime)
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps.children),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 15:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        workInProgress.memoizedProps === renderExpirationTime
-          ? (current = bailoutOnAlreadyFinishedWork(current, workInProgress))
-          : (reconcileChildren(
-              current,
-              workInProgress,
-              renderExpirationTime.children
-            ),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime.children,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 13:
-      return updateContextProvider(
-        current,
-        workInProgress,
-        renderExpirationTime
-      );
-    case 12:
-      a: if (
-        ((fn = workInProgress.type),
-        (unmaskedContext = workInProgress.pendingProps),
-        (needsContext = workInProgress.memoizedProps),
-        (props = fn._currentValue),
-        (props$jscomp$0 = fn._changedBits),
-        didPerformWorkStackCursor.current ||
-          0 !== props$jscomp$0 ||
-          needsContext !== unmaskedContext)
-      ) {
-        workInProgress.memoizedProps = unmaskedContext;
-        ctor = unmaskedContext.unstable_observedBits;
-        if (void 0 === ctor || null === ctor) ctor = 1073741823;
-        workInProgress.stateNode = ctor;
-        if (0 !== (props$jscomp$0 & ctor))
+      a: {
+        updateExpirationTime = workInProgress.type._context;
+        fn = workInProgress.pendingProps;
+        unmaskedContext = workInProgress.memoizedProps;
+        needsContext = fn.value;
+        workInProgress.memoizedProps = fn;
+        if (null === unmaskedContext) needsContext = 1073741823;
+        else if (unmaskedContext.value === fn.value) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((props = unmaskedContext.value),
+          (props === needsContext &&
+            (0 !== props || 1 / props === 1 / needsContext)) ||
+            (props !== props && needsContext !== needsContext))
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((needsContext =
+            "function" === typeof updateExpirationTime._calculateChangedBits
+              ? updateExpirationTime._calculateChangedBits(props, needsContext)
+              : 1073741823),
+          (needsContext |= 0),
+          0 === needsContext)
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+        } else
           propagateContextChange(
             workInProgress,
-            fn,
-            props$jscomp$0,
+            updateExpirationTime,
+            needsContext,
             renderExpirationTime
           );
-        else if (needsContext === unmaskedContext) {
-          current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-          break a;
-        }
-        renderExpirationTime = unmaskedContext.children;
-        renderExpirationTime = renderExpirationTime(props);
-        workInProgress.effectTag |= 1;
-        reconcileChildren(current, workInProgress, renderExpirationTime);
-        current = workInProgress.child;
-      } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-      return current;
+        workInProgress.stateNode = needsContext;
+        pushProvider(workInProgress);
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          fn.children,
+          renderExpirationTime
+        );
+        current$$1 = workInProgress.child;
+      }
+      return current$$1;
+    case 12:
+      return (
+        (unmaskedContext = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (unmaskedContext = readContext(
+          unmaskedContext,
+          updateExpirationTime.unstable_observedBits
+        )),
+        (fn = fn(unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
+      );
     default:
       invariant(
         !1,
@@ -3947,181 +4070,16 @@ updateHostComponent$1 = function(current, workInProgress, updatePayload) {
 updateHostText$1 = function(current, workInProgress, oldText, newText) {
   oldText !== newText && (workInProgress.effectTag |= 4);
 };
-function completeWork(current, workInProgress) {
-  var newProps = workInProgress.pendingProps;
-  switch (workInProgress.tag) {
-    case 1:
-      return null;
-    case 2:
-      return popContextProvider(workInProgress), null;
-    case 3:
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      newProps = workInProgress.stateNode;
-      newProps.pendingContext &&
-        ((newProps.context = newProps.pendingContext),
-        (newProps.pendingContext = null));
-      if (null === current || null === current.child)
-        workInProgress.effectTag &= -3;
-      updateHostContainer(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      var rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        ),
-        type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode) {
-        var oldProps = current.memoizedProps,
-          currentHostContext = requiredContext(contextStackCursor$1.current);
-        updateHostComponent$1(
-          current,
-          workInProgress,
-          emptyObject,
-          type,
-          oldProps,
-          newProps,
-          rootContainerInstance,
-          currentHostContext
-        );
-        current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      } 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
-          );
-        current = requiredContext(contextStackCursor$1.current);
-        oldProps = allocateTag();
-        currentHostContext = ReactNativeViewConfigRegistry.get(type);
-        invariant(
-          "RCTView" !== type || !current.isInAParentText,
-          "Nesting of <View> within <Text> is not currently supported."
-        );
-        var updatePayload = diffProperties(
-          null,
-          emptyObject$1,
-          newProps,
-          currentHostContext.validAttributes
-        );
-        UIManager.createView(
-          oldProps,
-          currentHostContext.uiViewClassName,
-          rootContainerInstance,
-          updatePayload
-        );
-        currentHostContext = new ReactNativeFiberHostComponent(
-          oldProps,
-          currentHostContext
-        );
-        instanceCache[oldProps] = workInProgress;
-        instanceProps[oldProps] = newProps;
-        a: for (oldProps = workInProgress.child; null !== oldProps; ) {
-          if (5 === oldProps.tag || 6 === oldProps.tag)
-            currentHostContext._children.push(oldProps.stateNode);
-          else if (4 !== oldProps.tag && null !== oldProps.child) {
-            oldProps.child.return = oldProps;
-            oldProps = oldProps.child;
-            continue;
-          }
-          if (oldProps === workInProgress) break;
-          for (; null === oldProps.sibling; ) {
-            if (null === oldProps.return || oldProps.return === workInProgress)
-              break a;
-            oldProps = oldProps.return;
-          }
-          oldProps.sibling.return = oldProps.return;
-          oldProps = oldProps.sibling;
-        }
-        finalizeInitialChildren(
-          currentHostContext,
-          type,
-          newProps,
-          rootContainerInstance,
-          current
-        ) && (workInProgress.effectTag |= 4);
-        workInProgress.stateNode = currentHostContext;
-        null !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      }
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        updateHostText$1(
-          current,
-          workInProgress,
-          current.memoizedProps,
-          newProps
-        );
-      else {
-        if ("string" !== typeof 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
-          );
-        rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        );
-        type = requiredContext(contextStackCursor$1.current);
-        invariant(
-          type.isInAParentText,
-          "Text strings must be rendered within a <Text> component."
-        );
-        type = allocateTag();
-        UIManager.createView(type, "RCTRawText", rootContainerInstance, {
-          text: newProps
-        });
-        instanceCache[type] = workInProgress;
-        workInProgress.stateNode = type;
-      }
-      return null;
-    case 14:
-      return null;
-    case 16:
-      return null;
-    case 10:
-      return null;
-    case 11:
-      return null;
-    case 15:
-      return null;
-    case 4:
-      return (
-        popHostContainer(workInProgress),
-        updateHostContainer(workInProgress),
-        null
-      );
-    case 13:
-      return popProvider(workInProgress), null;
-    case 12:
-      return null;
-    case 0:
-      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."
-      );
-  }
-}
 function logError(boundary, errorInfo) {
   var source = errorInfo.source,
     stack = errorInfo.stack;
   null === stack &&
     null !== source &&
-    (stack = getStackAddendumByWorkInProgressFiber(source));
-  null !== source && getComponentName(source);
+    (stack = getStackByFiberInDevAndProd(source));
+  null !== source && getComponentName(source.type);
   source = null !== stack ? stack : "";
   errorInfo = errorInfo.value;
-  null !== boundary && 2 === boundary.tag && getComponentName(boundary);
+  null !== boundary && 2 === boundary.tag && getComponentName(boundary.type);
   try {
     if (errorInfo instanceof Error) {
       var message = errorInfo.message,
@@ -4143,37 +4101,38 @@ function logError(boundary, errorInfo) {
     (e && e.suppressReactErrorLogging) || console.error(e);
   }
 }
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (null !== ref)
     if ("function" === typeof ref)
       try {
         ref(null);
       } catch (refError) {
-        captureCommitPhaseError(current, refError);
+        captureCommitPhaseError(current$$1, refError);
       }
     else ref.current = null;
 }
-function commitUnmount(current) {
-  "function" === typeof onCommitUnmount && onCommitUnmount(current);
-  switch (current.tag) {
+function commitUnmount(current$$1) {
+  "function" === typeof onCommitFiberUnmount &&
+    onCommitFiberUnmount(current$$1);
+  switch (current$$1.tag) {
     case 2:
-      safelyDetachRef(current);
-      var instance = current.stateNode;
+      safelyDetachRef(current$$1);
+      var instance = current$$1.stateNode;
       if ("function" === typeof instance.componentWillUnmount)
         try {
-          (instance.props = current.memoizedProps),
-            (instance.state = current.memoizedState),
+          (instance.props = current$$1.memoizedProps),
+            (instance.state = current$$1.memoizedState),
             instance.componentWillUnmount();
         } catch (unmountError) {
-          captureCommitPhaseError(current, unmountError);
+          captureCommitPhaseError(current$$1, unmountError);
         }
       break;
     case 5:
-      safelyDetachRef(current);
+      safelyDetachRef(current$$1);
       break;
     case 4:
-      unmountHostComponents(current);
+      unmountHostComponents(current$$1);
   }
 }
 function isHostParent(fiber) {
@@ -4324,9 +4283,9 @@ function commitPlacement(finishedWork) {
     node = node.sibling;
   }
 }
-function unmountHostComponents(current) {
+function unmountHostComponents(current$$1) {
   for (
-    var node = current,
+    var node = current$$1,
       currentParentIsValid = !1,
       currentParent = void 0,
       currentParentIsContainer = void 0;
@@ -4391,7 +4350,8 @@ function unmountHostComponents(current) {
       }
     } else if (
       (4 === node.tag
-        ? (currentParent = node.stateNode.containerInfo)
+        ? ((currentParent = node.stateNode.containerInfo),
+          (currentParentIsContainer = !0))
         : commitUnmount(node),
       null !== node.child)
     ) {
@@ -4399,9 +4359,9 @@ function unmountHostComponents(current) {
       node = node.child;
       continue;
     }
-    if (node === current) break;
+    if (node === current$$1) break;
     for (; null === node.sibling; ) {
-      if (null === node.return || node.return === current) return;
+      if (null === node.return || node.return === current$$1) return;
       node = node.return;
       4 === node.tag && (currentParentIsValid = !1);
     }
@@ -4409,7 +4369,7 @@ function unmountHostComponents(current) {
     node = node.sibling;
   }
 }
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case 2:
       break;
@@ -4417,7 +4377,7 @@ function commitWork(current, finishedWork) {
       var instance = finishedWork.stateNode;
       if (null != instance) {
         var newProps = finishedWork.memoizedProps;
-        current = null !== current ? current.memoizedProps : newProps;
+        current$$1 = null !== current$$1 ? current$$1.memoizedProps : newProps;
         var updatePayload = finishedWork.updateQueue;
         finishedWork.updateQueue = null;
         null !== updatePayload &&
@@ -4425,7 +4385,7 @@ function commitWork(current, finishedWork) {
           (instanceProps[instance._nativeTag] = newProps),
           (newProps = diffProperties(
             null,
-            current,
+            current$$1,
             newProps,
             finishedWork.validAttributes
           )),
@@ -4503,10 +4463,12 @@ function unwindWork(workInProgress) {
         popHostContainer(workInProgress),
         popTopLevelContextObject(workInProgress),
         (effectTag = workInProgress.effectTag),
-        effectTag & 1024
-          ? ((workInProgress.effectTag = (effectTag & -1025) | 64),
-            workInProgress)
-          : null
+        invariant(
+          0 === (effectTag & 64),
+          "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."
+        ),
+        (workInProgress.effectTag = (effectTag & -1025) | 64),
+        workInProgress
       );
     case 5:
       return popHostContext(workInProgress), null;
@@ -4526,16 +4488,14 @@ function unwindWork(workInProgress) {
       return null;
   }
 }
-var originalStartTimeMs = now$1(),
-  mostRecentCurrentTime = 2,
-  mostRecentCurrentTimeMs = originalStartTimeMs,
+var Dispatcher = { readContext: readContext },
+  ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
   lastUniqueAsyncExpiration = 0,
   expirationContext = 0,
   isWorking = !1,
   nextUnitOfWork = null,
   nextRoot = null,
   nextRenderExpirationTime = 0,
-  nextLatestTimeoutMs = -1,
   nextRenderDidError = !1,
   nextEffect = null,
   isCommitting$1 = !1,
@@ -4569,72 +4529,248 @@ function resetStack() {
     }
   nextRoot = null;
   nextRenderExpirationTime = 0;
-  nextLatestTimeoutMs = -1;
   nextRenderDidError = !1;
   nextUnitOfWork = null;
 }
-function completeUnitOfWork(workInProgress$jscomp$0) {
+function completeUnitOfWork(workInProgress) {
   for (;;) {
-    var current = workInProgress$jscomp$0.alternate,
-      returnFiber = workInProgress$jscomp$0.return,
-      siblingFiber = workInProgress$jscomp$0.sibling;
-    if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
-      current = completeWork(
-        current,
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      var workInProgress = workInProgress$jscomp$0;
+    var current$$1 = workInProgress.alternate,
+      returnFiber = workInProgress.return,
+      siblingFiber = workInProgress.sibling;
+    if (0 === (workInProgress.effectTag & 512)) {
+      var current = current$$1;
+      current$$1 = workInProgress;
+      var newProps = current$$1.pendingProps;
+      switch (current$$1.tag) {
+        case 1:
+          break;
+        case 2:
+          popContextProvider(current$$1);
+          break;
+        case 3:
+          popHostContainer(current$$1);
+          popTopLevelContextObject(current$$1);
+          newProps = current$$1.stateNode;
+          newProps.pendingContext &&
+            ((newProps.context = newProps.pendingContext),
+            (newProps.pendingContext = null));
+          if (null === current || null === current.child)
+            current$$1.effectTag &= -3;
+          updateHostContainer(current$$1);
+          break;
+        case 5:
+          popHostContext(current$$1);
+          var rootContainerInstance = requiredContext(
+              rootInstanceStackCursor.current
+            ),
+            type = current$$1.type;
+          if (null !== current && null != current$$1.stateNode) {
+            var oldProps = current.memoizedProps,
+              currentHostContext = requiredContext(
+                contextStackCursor$1.current
+              );
+            updateHostComponent$1(
+              current,
+              current$$1,
+              UPDATE_SIGNAL,
+              type,
+              oldProps,
+              newProps,
+              rootContainerInstance,
+              currentHostContext
+            );
+            current.ref !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else if (newProps) {
+            current = requiredContext(contextStackCursor$1.current);
+            var type$jscomp$0 = type;
+            oldProps = newProps;
+            var rootContainerInstance$jscomp$0 = rootContainerInstance,
+              hostContext = current;
+            currentHostContext = current$$1;
+            var tag = allocateTag(),
+              viewConfig = ReactNativeViewConfigRegistry.get(type$jscomp$0);
+            invariant(
+              "RCTView" !== type$jscomp$0 || !hostContext.isInAParentText,
+              "Nesting of <View> within <Text> is not currently supported."
+            );
+            type$jscomp$0 = diffProperties(
+              null,
+              emptyObject,
+              oldProps,
+              viewConfig.validAttributes
+            );
+            UIManager.createView(
+              tag,
+              viewConfig.uiViewClassName,
+              rootContainerInstance$jscomp$0,
+              type$jscomp$0
+            );
+            rootContainerInstance$jscomp$0 = new ReactNativeFiberHostComponent(
+              tag,
+              viewConfig
+            );
+            instanceCache[tag] = currentHostContext;
+            instanceProps[tag] = oldProps;
+            oldProps = rootContainerInstance$jscomp$0;
+            a: for (
+              currentHostContext = oldProps,
+                tag = current$$1,
+                rootContainerInstance$jscomp$0 = tag.child;
+              null !== rootContainerInstance$jscomp$0;
+
+            ) {
+              if (
+                5 === rootContainerInstance$jscomp$0.tag ||
+                6 === rootContainerInstance$jscomp$0.tag
+              )
+                currentHostContext._children.push(
+                  rootContainerInstance$jscomp$0.stateNode
+                );
+              else if (
+                4 !== rootContainerInstance$jscomp$0.tag &&
+                null !== rootContainerInstance$jscomp$0.child
+              ) {
+                rootContainerInstance$jscomp$0.child.return = rootContainerInstance$jscomp$0;
+                rootContainerInstance$jscomp$0 =
+                  rootContainerInstance$jscomp$0.child;
+                continue;
+              }
+              if (rootContainerInstance$jscomp$0 === tag) break;
+              for (; null === rootContainerInstance$jscomp$0.sibling; ) {
+                if (
+                  null === rootContainerInstance$jscomp$0.return ||
+                  rootContainerInstance$jscomp$0.return === tag
+                )
+                  break a;
+                rootContainerInstance$jscomp$0 =
+                  rootContainerInstance$jscomp$0.return;
+              }
+              rootContainerInstance$jscomp$0.sibling.return =
+                rootContainerInstance$jscomp$0.return;
+              rootContainerInstance$jscomp$0 =
+                rootContainerInstance$jscomp$0.sibling;
+            }
+            finalizeInitialChildren(
+              oldProps,
+              type,
+              newProps,
+              rootContainerInstance,
+              current
+            ) && (current$$1.effectTag |= 4);
+            current$$1.stateNode = oldProps;
+            null !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else
+            invariant(
+              null !== current$$1.stateNode,
+              "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+            );
+          break;
+        case 6:
+          type = newProps;
+          current && null != current$$1.stateNode
+            ? updateHostText$1(current, current$$1, current.memoizedProps, type)
+            : ("string" !== typeof type &&
+                invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                ),
+              (current = requiredContext(rootInstanceStackCursor.current)),
+              (rootContainerInstance = requiredContext(
+                contextStackCursor$1.current
+              )),
+              (newProps = current$$1),
+              invariant(
+                rootContainerInstance.isInAParentText,
+                "Text strings must be rendered within a <Text> component."
+              ),
+              (rootContainerInstance = allocateTag()),
+              UIManager.createView(
+                rootContainerInstance,
+                "RCTRawText",
+                current,
+                { text: type }
+              ),
+              (instanceCache[rootContainerInstance] = current$$1),
+              (newProps.stateNode = rootContainerInstance));
+          break;
+        case 14:
+          break;
+        case 16:
+          break;
+        case 10:
+          break;
+        case 11:
+          break;
+        case 15:
+          break;
+        case 4:
+          popHostContainer(current$$1);
+          updateHostContainer(current$$1);
+          break;
+        case 13:
+          popProvider(current$$1);
+          break;
+        case 12:
+          break;
+        case 0:
+          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."
+          );
+      }
+      current$$1 = nextUnitOfWork = null;
+      newProps = workInProgress;
       if (
         1073741823 === nextRenderExpirationTime ||
-        1073741823 !== workInProgress.expirationTime
+        1073741823 !== newProps.childExpirationTime
       ) {
-        var newExpirationTime = 0;
-        switch (workInProgress.tag) {
-          case 3:
-          case 2:
-            var updateQueue = workInProgress.updateQueue;
-            null !== updateQueue &&
-              (newExpirationTime = updateQueue.expirationTime);
+        rootContainerInstance = 0;
+        for (type = newProps.child; null !== type; ) {
+          current = type.expirationTime;
+          oldProps = type.childExpirationTime;
+          if (
+            0 === rootContainerInstance ||
+            (0 !== current && current < rootContainerInstance)
+          )
+            rootContainerInstance = current;
+          if (
+            0 === rootContainerInstance ||
+            (0 !== oldProps && oldProps < rootContainerInstance)
+          )
+            rootContainerInstance = oldProps;
+          type = type.sibling;
         }
-        for (updateQueue = workInProgress.child; null !== updateQueue; )
-          0 !== updateQueue.expirationTime &&
-            (0 === newExpirationTime ||
-              newExpirationTime > updateQueue.expirationTime) &&
-            (newExpirationTime = updateQueue.expirationTime),
-            (updateQueue = updateQueue.sibling);
-        workInProgress.expirationTime = newExpirationTime;
+        newProps.childExpirationTime = rootContainerInstance;
       }
-      if (null !== current) return current;
+      if (null !== current$$1) return current$$1;
       null !== returnFiber &&
         0 === (returnFiber.effectTag & 512) &&
         (null === returnFiber.firstEffect &&
-          (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect),
-        null !== workInProgress$jscomp$0.lastEffect &&
+          (returnFiber.firstEffect = workInProgress.firstEffect),
+        null !== workInProgress.lastEffect &&
           (null !== returnFiber.lastEffect &&
-            (returnFiber.lastEffect.nextEffect =
-              workInProgress$jscomp$0.firstEffect),
-          (returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect)),
-        1 < workInProgress$jscomp$0.effectTag &&
+            (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect),
+          (returnFiber.lastEffect = workInProgress.lastEffect)),
+        1 < workInProgress.effectTag &&
           (null !== returnFiber.lastEffect
-            ? (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0)
-            : (returnFiber.firstEffect = workInProgress$jscomp$0),
-          (returnFiber.lastEffect = workInProgress$jscomp$0)));
+            ? (returnFiber.lastEffect.nextEffect = workInProgress)
+            : (returnFiber.firstEffect = workInProgress),
+          (returnFiber.lastEffect = workInProgress)));
     } else {
-      workInProgress$jscomp$0 = unwindWork(
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      if (null !== workInProgress$jscomp$0)
-        return (
-          (workInProgress$jscomp$0.effectTag &= 511), workInProgress$jscomp$0
-        );
+      workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+      if (null !== workInProgress)
+        return (workInProgress.effectTag &= 511), workInProgress;
       null !== returnFiber &&
         ((returnFiber.firstEffect = returnFiber.lastEffect = null),
         (returnFiber.effectTag |= 512));
     }
     if (null !== siblingFiber) return siblingFiber;
-    if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;
+    if (null !== returnFiber) workInProgress = returnFiber;
     else break;
   }
   return null;
@@ -4646,32 +4782,31 @@ function performUnitOfWork(workInProgress) {
     nextRenderExpirationTime
   );
   null === next && (next = completeUnitOfWork(workInProgress));
-  ReactCurrentOwner.current = null;
+  ReactCurrentOwner$2.current = null;
   return next;
 }
-function renderRoot(root$jscomp$0, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isWorking = !0;
-  var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
+  var expirationTime = root.nextExpirationTimeToWorkOn;
   if (
     expirationTime !== nextRenderExpirationTime ||
-    root$jscomp$0 !== nextRoot ||
+    root !== nextRoot ||
     null === nextUnitOfWork
   )
     resetStack(),
-      (nextRoot = root$jscomp$0),
+      (nextRoot = root),
       (nextRenderExpirationTime = expirationTime),
-      (nextLatestTimeoutMs = -1),
-      (nextRenderDidError = !1),
       (nextUnitOfWork = createWorkInProgress(
         nextRoot.current,
         null,
         nextRenderExpirationTime
       )),
-      (root$jscomp$0.pendingCommitExpirationTime = 0);
+      (root.pendingCommitExpirationTime = 0);
   var didFatal = !1;
   do {
     try {
@@ -4689,110 +4824,117 @@ function renderRoot(root$jscomp$0, isYieldy) {
           null !== nextUnitOfWork,
           "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it."
         );
-        isYieldy = nextUnitOfWork;
-        var returnFiber = isYieldy.return;
-        if (null === returnFiber) {
-          didFatal = !0;
-          onUncaughtError(thrownValue);
-          break;
-        }
-        a: {
-          var root = root$jscomp$0,
-            returnFiber$jscomp$0 = returnFiber,
-            sourceFiber = isYieldy,
-            value = thrownValue;
-          returnFiber = nextRenderExpirationTime;
-          sourceFiber.effectTag |= 512;
-          sourceFiber.firstEffect = sourceFiber.lastEffect = null;
-          nextRenderDidError = !0;
-          if (
-            (root.didError || 1 === returnFiber) &&
-            (returnFiber === root.latestPendingTime ||
-              returnFiber === root.latestSuspendedTime)
-          ) {
-            value = createCapturedValue(value, sourceFiber);
-            root = returnFiber$jscomp$0;
+        var sourceFiber = nextUnitOfWork,
+          returnFiber = sourceFiber.return;
+        if (null === returnFiber) (didFatal = !0), onUncaughtError(thrownValue);
+        else {
+          a: {
+            var returnFiber$jscomp$0 = returnFiber,
+              sourceFiber$jscomp$0 = sourceFiber,
+              value = thrownValue;
+            returnFiber = nextRenderExpirationTime;
+            sourceFiber$jscomp$0.effectTag |= 512;
+            sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+            nextRenderDidError = !0;
+            value = createCapturedValue(value, sourceFiber$jscomp$0);
             do {
-              switch (root.tag) {
+              switch (returnFiber$jscomp$0.tag) {
                 case 3:
-                  root.effectTag |= 1024;
-                  value = createRootErrorUpdate(root, value, returnFiber);
-                  enqueueCapturedUpdate(root, value, returnFiber);
+                  returnFiber$jscomp$0.effectTag |= 1024;
+                  returnFiber$jscomp$0.expirationTime = returnFiber;
+                  returnFiber = createRootErrorUpdate(
+                    returnFiber$jscomp$0,
+                    value,
+                    returnFiber
+                  );
+                  enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                   break a;
                 case 2:
+                  sourceFiber$jscomp$0 = value;
+                  var instance = returnFiber$jscomp$0.stateNode;
                   if (
-                    ((returnFiber$jscomp$0 = value),
-                    (sourceFiber = root.stateNode),
-                    0 === (root.effectTag & 64) &&
-                      null !== sourceFiber &&
-                      "function" === typeof sourceFiber.componentDidCatch &&
-                      (null === legacyErrorBoundariesThatAlreadyFailed ||
-                        !legacyErrorBoundariesThatAlreadyFailed.has(
-                          sourceFiber
-                        )))
+                    0 === (returnFiber$jscomp$0.effectTag & 64) &&
+                    null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))
                   ) {
-                    root.effectTag |= 1024;
-                    value = createClassErrorUpdate(
-                      root,
+                    returnFiber$jscomp$0.effectTag |= 1024;
+                    returnFiber$jscomp$0.expirationTime = returnFiber;
+                    returnFiber = createClassErrorUpdate(
                       returnFiber$jscomp$0,
+                      sourceFiber$jscomp$0,
                       returnFiber
                     );
-                    enqueueCapturedUpdate(root, value, returnFiber);
+                    enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                     break a;
                   }
               }
-              root = root.return;
-            } while (null !== root);
+              returnFiber$jscomp$0 = returnFiber$jscomp$0.return;
+            } while (null !== returnFiber$jscomp$0);
           }
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        nextUnitOfWork = completeUnitOfWork(isYieldy);
       }
     }
     break;
   } while (1);
   isWorking = !1;
-  didFatal
-    ? (root$jscomp$0.finishedWork = null)
-    : null === nextUnitOfWork
-      ? ((didFatal = root$jscomp$0.current.alternate),
-        invariant(
-          null !== didFatal,
-          "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
-        ),
-        0 === (didFatal.effectTag & 512)
-          ? ((root$jscomp$0.pendingCommitExpirationTime = expirationTime),
-            (root$jscomp$0.finishedWork = didFatal))
-          : (!nextRenderDidError ||
-            (expirationTime !== root$jscomp$0.latestPendingTime &&
-              expirationTime !== root$jscomp$0.latestSuspendedTime)
-              ? ((didFatal = root$jscomp$0.earliestPendingTime),
-                (isYieldy = root$jscomp$0.latestPendingTime),
-                didFatal === expirationTime
-                  ? (root$jscomp$0.earliestPendingTime =
-                      isYieldy === expirationTime
-                        ? (root$jscomp$0.latestPendingTime = 0)
-                        : isYieldy)
-                  : isYieldy === expirationTime &&
-                    (root$jscomp$0.latestPendingTime = didFatal),
-                (didFatal = root$jscomp$0.latestSuspendedTime),
-                didFatal === expirationTime &&
-                  (root$jscomp$0.latestPingedTime = 0),
-                (isYieldy = root$jscomp$0.earliestSuspendedTime),
-                0 === isYieldy
-                  ? (root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime)
-                  : isYieldy > expirationTime
-                    ? (root$jscomp$0.earliestSuspendedTime = expirationTime)
-                    : didFatal < expirationTime &&
-                      (root$jscomp$0.latestSuspendedTime = expirationTime))
-              : (root$jscomp$0.didError = !0),
-            findNextPendingPriorityLevel(root$jscomp$0),
-            onSuspend(
-              root$jscomp$0,
-              expirationTime,
-              root$jscomp$0.expirationTime,
-              nextLatestTimeoutMs
-            )))
-      : (root$jscomp$0.finishedWork = null);
+  lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = ReactCurrentOwner$2.currentDispatcher = null;
+  if (didFatal) (nextRoot = null), (root.finishedWork = null);
+  else if (null !== nextUnitOfWork) root.finishedWork = null;
+  else {
+    isYieldy = root.current.alternate;
+    invariant(
+      null !== isYieldy,
+      "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
+    );
+    nextRoot = null;
+    if (nextRenderDidError) {
+      didFatal = root.latestPendingTime;
+      sourceFiber = root.latestSuspendedTime;
+      returnFiber = root.latestPingedTime;
+      if (
+        (0 !== didFatal && didFatal > expirationTime) ||
+        (0 !== sourceFiber && sourceFiber > expirationTime) ||
+        (0 !== returnFiber && returnFiber > expirationTime)
+      ) {
+        root.didError = !1;
+        isExpired = root.latestPingedTime;
+        0 !== isExpired &&
+          isExpired <= expirationTime &&
+          (root.latestPingedTime = 0);
+        isExpired = root.earliestPendingTime;
+        isYieldy = root.latestPendingTime;
+        isExpired === expirationTime
+          ? (root.earliestPendingTime =
+              isYieldy === expirationTime
+                ? (root.latestPendingTime = 0)
+                : isYieldy)
+          : isYieldy === expirationTime && (root.latestPendingTime = isExpired);
+        isExpired = root.earliestSuspendedTime;
+        isYieldy = root.latestSuspendedTime;
+        0 === isExpired
+          ? (root.earliestSuspendedTime = root.latestSuspendedTime = expirationTime)
+          : isExpired > expirationTime
+            ? (root.earliestSuspendedTime = expirationTime)
+            : isYieldy < expirationTime &&
+              (root.latestSuspendedTime = expirationTime);
+        findNextExpirationTimeToWorkOn(expirationTime, root);
+        root.expirationTime = root.expirationTime;
+        return;
+      }
+      if (!root.didError && !isExpired) {
+        root.didError = !0;
+        root.nextExpirationTimeToWorkOn = expirationTime;
+        root.expirationTime = 1;
+        return;
+      }
+    }
+    root.pendingCommitExpirationTime = expirationTime;
+    root.finishedWork = isYieldy;
+  }
 }
 function captureCommitPhaseError(fiber, error) {
   var JSCompiler_inline_result;
@@ -4818,7 +4960,7 @@ function captureCommitPhaseError(fiber, error) {
           ) {
             fiber = createCapturedValue(error, fiber);
             fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
-            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+            enqueueUpdate(JSCompiler_inline_result, fiber);
             scheduleWork(JSCompiler_inline_result, 1);
             JSCompiler_inline_result = void 0;
             break a;
@@ -4827,7 +4969,7 @@ function captureCommitPhaseError(fiber, error) {
         case 3:
           fiber = createCapturedValue(error, fiber);
           fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
-          enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+          enqueueUpdate(JSCompiler_inline_result, fiber);
           scheduleWork(JSCompiler_inline_result, 1);
           JSCompiler_inline_result = void 0;
           break a;
@@ -4841,23 +4983,25 @@ function captureCommitPhaseError(fiber, error) {
         JSCompiler_inline_result,
         1
       )),
-      enqueueUpdate(fiber, JSCompiler_inline_result, 1),
+      enqueueUpdate(fiber, JSCompiler_inline_result),
       scheduleWork(fiber, 1));
     JSCompiler_inline_result = void 0;
   }
   return JSCompiler_inline_result;
 }
 function computeExpirationForFiber(currentTime, fiber) {
-  currentTime =
-    0 !== expirationContext
-      ? expirationContext
-      : isWorking
-        ? isCommitting$1 ? 1 : nextRenderExpirationTime
-        : fiber.mode & 1
-          ? isBatchingInteractiveUpdates
+  0 !== expirationContext
+    ? (currentTime = expirationContext)
+    : isWorking
+      ? (currentTime = isCommitting$1 ? 1 : nextRenderExpirationTime)
+      : fiber.mode & 1
+        ? ((currentTime = isBatchingInteractiveUpdates
             ? 2 + 10 * ((((currentTime - 2 + 15) / 10) | 0) + 1)
-            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)
-          : 1;
+            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)),
+          null !== nextRoot &&
+            currentTime === nextRenderExpirationTime &&
+            (currentTime += 1))
+        : (currentTime = 1);
   isBatchingInteractiveUpdates &&
     (0 === lowestPendingInteractiveExpirationTime ||
       currentTime > lowestPendingInteractiveExpirationTime) &&
@@ -4865,35 +5009,51 @@ function computeExpirationForFiber(currentTime, fiber) {
   return currentTime;
 }
 function scheduleWork(fiber, expirationTime) {
-  for (; null !== fiber; ) {
+  a: {
     if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime)
       fiber.expirationTime = expirationTime;
-    null !== fiber.alternate &&
-      (0 === fiber.alternate.expirationTime ||
-        fiber.alternate.expirationTime > expirationTime) &&
-      (fiber.alternate.expirationTime = expirationTime);
-    if (null === fiber.return)
-      if (3 === fiber.tag) {
-        var root = fiber.stateNode;
-        !isWorking &&
-          0 !== nextRenderExpirationTime &&
-          expirationTime < nextRenderExpirationTime &&
-          resetStack();
-        markPendingPriorityLevel(root, expirationTime);
-        (isWorking && !isCommitting$1 && nextRoot === root) ||
-          requestWork(root, root.expirationTime);
-        nestedUpdateCount > NESTED_UPDATE_LIMIT &&
-          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."
-          );
-      } else break;
-    fiber = fiber.return;
+    var alternate = fiber.alternate;
+    null !== alternate &&
+      (0 === alternate.expirationTime ||
+        alternate.expirationTime > expirationTime) &&
+      (alternate.expirationTime = expirationTime);
+    var node = fiber.return;
+    if (null === node && 3 === fiber.tag) fiber = fiber.stateNode;
+    else {
+      for (; null !== node; ) {
+        alternate = node.alternate;
+        if (
+          0 === node.childExpirationTime ||
+          node.childExpirationTime > expirationTime
+        )
+          node.childExpirationTime = expirationTime;
+        null !== alternate &&
+          (0 === alternate.childExpirationTime ||
+            alternate.childExpirationTime > expirationTime) &&
+          (alternate.childExpirationTime = expirationTime);
+        if (null === node.return && 3 === node.tag) {
+          fiber = node.stateNode;
+          break a;
+        }
+        node = node.return;
+      }
+      fiber = null;
+    }
   }
-}
-function recalculateCurrentTime() {
-  mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
-  return (mostRecentCurrentTime = ((mostRecentCurrentTimeMs / 10) | 0) + 2);
+  null !== fiber &&
+    (!isWorking &&
+      0 !== nextRenderExpirationTime &&
+      expirationTime < nextRenderExpirationTime &&
+      resetStack(),
+    markPendingPriorityLevel(fiber, expirationTime),
+    (isWorking && !isCommitting$1 && nextRoot === fiber) ||
+      requestWork(fiber, fiber.expirationTime),
+    nestedUpdateCount > NESTED_UPDATE_LIMIT &&
+      ((nestedUpdateCount = 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."
+      )));
 }
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
@@ -4920,9 +5080,16 @@ var firstScheduledRoot = null,
   isUnbatchingUpdates = !1,
   isBatchingInteractiveUpdates = !1,
   completedBatches = null,
-  NESTED_UPDATE_LIMIT = 1e3,
+  originalStartTimeMs = now$1(),
+  currentRendererTime = ((originalStartTimeMs / 10) | 0) + 2,
+  currentSchedulerTime = currentRendererTime,
+  NESTED_UPDATE_LIMIT = 50,
   nestedUpdateCount = 0,
+  lastCommittedRootDuringThisBatch = null,
   timeHeuristicForUnitOfWork = 1;
+function recomputeCurrentRendererTime() {
+  currentRendererTime = (((now$1() - originalStartTimeMs) / 10) | 0) + 2;
+}
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (0 !== callbackExpirationTime) {
     if (expirationTime > callbackExpirationTime) return;
@@ -4937,21 +5104,16 @@ function scheduleCallbackWithExpirationTime(expirationTime) {
   scheduledCallback = performAsyncWork;
   callbackID = setTimeout(setTimeoutCallback, 1);
 }
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  0 <= timeoutMs &&
-    setTimeout(function() {
-      var latestSuspendedTime = root.latestSuspendedTime;
-      0 !== latestSuspendedTime &&
-        latestSuspendedTime <= suspendedExpirationTime &&
-        ((latestSuspendedTime = root.latestPingedTime),
-        0 === latestSuspendedTime ||
-          latestSuspendedTime < suspendedExpirationTime) &&
-        (root.latestPingedTime = suspendedExpirationTime);
-      findNextPendingPriorityLevel(root);
-      latestSuspendedTime = root.expirationTime;
-      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
-    }, timeoutMs);
-  root.expirationTime = expirationTime;
+function requestCurrentTime() {
+  if (isRendering) return currentSchedulerTime;
+  findHighestPriorityRoot();
+  if (
+    0 === nextFlushedExpirationTime ||
+    1073741823 === nextFlushedExpirationTime
+  )
+    recomputeCurrentRendererTime(),
+      (currentSchedulerTime = currentRendererTime);
+  return currentSchedulerTime;
 }
 function requestWork(root, expirationTime) {
   if (null === root.nextScheduledRoot)
@@ -4974,7 +5136,7 @@ function requestWork(root, expirationTime) {
       ? isUnbatchingUpdates &&
         ((nextFlushedRoot = root),
         (nextFlushedExpirationTime = 1),
-        performWorkOnRoot(root, 1, !1))
+        performWorkOnRoot(root, 1, !0))
       : 1 === expirationTime
         ? performWork(1, null)
         : scheduleCallbackWithExpirationTime(expirationTime));
@@ -5023,12 +5185,6 @@ function findHighestPriorityRoot() {
         root = root.nextScheduledRoot;
       }
     }
-  previousScheduledRoot = nextFlushedRoot;
-  null !== previousScheduledRoot &&
-  previousScheduledRoot === highestPriorityRoot &&
-  1 === highestPriorityWork
-    ? nestedUpdateCount++
-    : (nestedUpdateCount = 0);
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -5040,18 +5196,23 @@ function performWork(minExpirationTime, dl) {
   findHighestPriorityRoot();
   if (null !== deadline)
     for (
-      ;
+      recomputeCurrentRendererTime(),
+        currentSchedulerTime = currentRendererTime;
       null !== nextFlushedRoot &&
       0 !== nextFlushedExpirationTime &&
       (0 === minExpirationTime ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime);
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime);
 
     )
-      recalculateCurrentTime(),
-        performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
-        findHighestPriorityRoot();
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      ),
+        findHighestPriorityRoot(),
+        recomputeCurrentRendererTime(),
+        (currentSchedulerTime = currentRendererTime);
   else
     for (
       ;
@@ -5061,22 +5222,22 @@ function performWork(minExpirationTime, dl) {
         minExpirationTime >= nextFlushedExpirationTime);
 
     )
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1),
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
         findHighestPriorityRoot();
   null !== deadline && ((callbackExpirationTime = 0), (callbackID = null));
   0 !== nextFlushedExpirationTime &&
     scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
   deadline = null;
   deadlineDidExpire = !1;
-  finishRendering();
-}
-function finishRendering() {
   nestedUpdateCount = 0;
-  if (null !== completedBatches) {
-    var batches = completedBatches;
-    completedBatches = null;
-    for (var i = 0; i < batches.length; i++) {
-      var batch = batches[i];
+  lastCommittedRootDuringThisBatch = null;
+  if (null !== completedBatches)
+    for (
+      minExpirationTime = completedBatches, completedBatches = null, dl = 0;
+      dl < minExpirationTime.length;
+      dl++
+    ) {
+      var batch = minExpirationTime[dl];
       try {
         batch._onComplete();
       } catch (error) {
@@ -5084,37 +5245,38 @@ function finishRendering() {
           ((hasUnhandledError = !0), (unhandledError = error));
       }
     }
-  }
   if (hasUnhandledError)
-    throw ((batches = unhandledError),
+    throw ((minExpirationTime = unhandledError),
     (unhandledError = null),
     (hasUnhandledError = !1),
-    batches);
+    minExpirationTime);
 }
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isRendering = !0;
-  isYieldy
-    ? ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot(root, isYieldy, expirationTime)
+  if (null === deadline || isExpired) {
+    var finishedWork = root.finishedWork;
+    null !== finishedWork
+      ? completeRoot(root, finishedWork, expirationTime)
+      : ((root.finishedWork = null),
+        renderRoot(root, !1, isExpired),
+        (finishedWork = root.finishedWork),
+        null !== finishedWork &&
+          completeRoot(root, finishedWork, expirationTime));
+  } else
+    (finishedWork = root.finishedWork),
+      null !== finishedWork
+        ? completeRoot(root, finishedWork, expirationTime)
         : ((root.finishedWork = null),
-          renderRoot(root, !0),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy &&
+          renderRoot(root, !0, isExpired),
+          (finishedWork = root.finishedWork),
+          null !== finishedWork &&
             (shouldYield()
-              ? (root.finishedWork = isYieldy)
-              : completeRoot(root, isYieldy, expirationTime))))
-    : ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot(root, isYieldy, expirationTime)
-        : ((root.finishedWork = null),
-          renderRoot(root, !1),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy && completeRoot(root, isYieldy, expirationTime)));
+              ? (root.finishedWork = finishedWork)
+              : completeRoot(root, finishedWork, expirationTime)));
   isRendering = !1;
 }
 function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
@@ -5132,6 +5294,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
     return;
   }
   root.finishedWork = null;
+  root === lastCommittedRootDuringThisBatch
+    ? nestedUpdateCount++
+    : ((lastCommittedRootDuringThisBatch = root), (nestedUpdateCount = 0));
   isCommitting$1 = isWorking = !0;
   invariant(
     root.current !== finishedWork$jscomp$0,
@@ -5144,34 +5309,39 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
   );
   root.pendingCommitExpirationTime = 0;
   firstBatch = finishedWork$jscomp$0.expirationTime;
-  recalculateCurrentTime();
+  var childExpirationTimeBeforeCommit =
+    finishedWork$jscomp$0.childExpirationTime;
+  firstBatch =
+    0 === firstBatch ||
+    (0 !== childExpirationTimeBeforeCommit &&
+      childExpirationTimeBeforeCommit < firstBatch)
+      ? childExpirationTimeBeforeCommit
+      : firstBatch;
   root.didError = !1;
-  if (0 === firstBatch)
-    (root.earliestPendingTime = 0),
+  0 === firstBatch
+    ? ((root.earliestPendingTime = 0),
       (root.latestPendingTime = 0),
       (root.earliestSuspendedTime = 0),
       (root.latestSuspendedTime = 0),
-      (root.latestPingedTime = 0);
-  else {
-    var latestPendingTime = root.latestPendingTime;
-    0 !== latestPendingTime &&
-      (latestPendingTime < firstBatch
-        ? (root.earliestPendingTime = root.latestPendingTime = 0)
-        : root.earliestPendingTime < firstBatch &&
-          (root.earliestPendingTime = root.latestPendingTime));
-    latestPendingTime = root.earliestSuspendedTime;
-    0 === latestPendingTime
-      ? markPendingPriorityLevel(root, firstBatch)
-      : firstBatch > root.latestSuspendedTime
-        ? ((root.earliestSuspendedTime = 0),
-          (root.latestSuspendedTime = 0),
-          (root.latestPingedTime = 0),
-          markPendingPriorityLevel(root, firstBatch))
-        : firstBatch < latestPendingTime &&
-          markPendingPriorityLevel(root, firstBatch);
-  }
-  findNextPendingPriorityLevel(root);
-  ReactCurrentOwner.current = null;
+      (root.latestPingedTime = 0))
+    : ((childExpirationTimeBeforeCommit = root.latestPendingTime),
+      0 !== childExpirationTimeBeforeCommit &&
+        (childExpirationTimeBeforeCommit < firstBatch
+          ? (root.earliestPendingTime = root.latestPendingTime = 0)
+          : root.earliestPendingTime < firstBatch &&
+            (root.earliestPendingTime = root.latestPendingTime)),
+      (childExpirationTimeBeforeCommit = root.earliestSuspendedTime),
+      0 === childExpirationTimeBeforeCommit
+        ? markPendingPriorityLevel(root, firstBatch)
+        : firstBatch > root.latestSuspendedTime
+          ? ((root.earliestSuspendedTime = 0),
+            (root.latestSuspendedTime = 0),
+            (root.latestPingedTime = 0),
+            markPendingPriorityLevel(root, firstBatch))
+          : firstBatch < childExpirationTimeBeforeCommit &&
+            markPendingPriorityLevel(root, firstBatch));
+  findNextExpirationTimeToWorkOn(0, root);
+  ReactCurrentOwner$2.current = null;
   1 < finishedWork$jscomp$0.effectTag
     ? null !== finishedWork$jscomp$0.lastEffect
       ? ((finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0),
@@ -5179,18 +5349,18 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
       : (firstBatch = finishedWork$jscomp$0)
     : (firstBatch = finishedWork$jscomp$0.firstEffect);
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    latestPendingTime = !1;
+    childExpirationTimeBeforeCommit = !1;
     var error = void 0;
     try {
       for (; null !== nextEffect; ) {
         if (nextEffect.effectTag & 256) {
-          var current = nextEffect.alternate,
+          var current$$1 = nextEffect.alternate,
             finishedWork = nextEffect;
           switch (finishedWork.tag) {
             case 2:
-              if (finishedWork.effectTag & 256 && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
+              if (finishedWork.effectTag & 256 && null !== current$$1) {
+                var prevProps = current$$1.memoizedProps,
+                  prevState = current$$1.memoizedState,
                   instance = finishedWork.stateNode;
                 instance.props = finishedWork.memoizedProps;
                 instance.state = finishedWork.memoizedState;
@@ -5216,9 +5386,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (latestPendingTime = !0), (error = e);
+      (childExpirationTimeBeforeCommit = !0), (error = e);
     }
-    latestPendingTime &&
+    childExpirationTimeBeforeCommit &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5227,15 +5397,15 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    current = !1;
+    current$$1 = !1;
     prevProps = void 0;
     try {
       for (; null !== nextEffect; ) {
         var effectTag = nextEffect.effectTag;
         if (effectTag & 128) {
-          var current$jscomp$0 = nextEffect.alternate;
-          if (null !== current$jscomp$0) {
-            var currentRef = current$jscomp$0.ref;
+          var current$$1$jscomp$0 = nextEffect.alternate;
+          if (null !== current$$1$jscomp$0) {
+            var currentRef = current$$1$jscomp$0.ref;
             null !== currentRef &&
               ("function" === typeof currentRef
                 ? currentRef(null)
@@ -5267,9 +5437,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (current = !0), (prevProps = e);
+      (current$$1 = !0), (prevProps = e);
     }
-    current &&
+    current$$1 &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5280,57 +5450,62 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
   root.current = finishedWork$jscomp$0;
   for (nextEffect = firstBatch; null !== nextEffect; ) {
     effectTag = !1;
-    current$jscomp$0 = void 0;
+    current$$1$jscomp$0 = void 0;
     try {
       for (currentRef = expirationTime; null !== nextEffect; ) {
         var effectTag$jscomp$0 = nextEffect.effectTag;
         if (effectTag$jscomp$0 & 36) {
-          var current$jscomp$1 = nextEffect.alternate;
-          current = nextEffect;
+          var current$$1$jscomp$1 = nextEffect.alternate;
+          current$$1 = nextEffect;
           prevProps = currentRef;
-          switch (current.tag) {
+          switch (current$$1.tag) {
             case 2:
-              var instance$jscomp$0 = current.stateNode;
-              if (current.effectTag & 4)
-                if (null === current$jscomp$1)
-                  (instance$jscomp$0.props = current.memoizedProps),
-                    (instance$jscomp$0.state = current.memoizedState),
+              var instance$jscomp$0 = current$$1.stateNode;
+              if (current$$1.effectTag & 4)
+                if (null === current$$1$jscomp$1)
+                  (instance$jscomp$0.props = current$$1.memoizedProps),
+                    (instance$jscomp$0.state = current$$1.memoizedState),
                     instance$jscomp$0.componentDidMount();
                 else {
-                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
-                    prevState$jscomp$0 = current$jscomp$1.memoizedState;
-                  instance$jscomp$0.props = current.memoizedProps;
-                  instance$jscomp$0.state = current.memoizedState;
+                  var prevProps$jscomp$0 = current$$1$jscomp$1.memoizedProps,
+                    prevState$jscomp$0 = current$$1$jscomp$1.memoizedState;
+                  instance$jscomp$0.props = current$$1.memoizedProps;
+                  instance$jscomp$0.state = current$$1.memoizedState;
                   instance$jscomp$0.componentDidUpdate(
                     prevProps$jscomp$0,
                     prevState$jscomp$0,
                     instance$jscomp$0.__reactInternalSnapshotBeforeUpdate
                   );
                 }
-              var updateQueue = current.updateQueue;
+              var updateQueue = current$$1.updateQueue;
               null !== updateQueue &&
-                ((instance$jscomp$0.props = current.memoizedProps),
-                (instance$jscomp$0.state = current.memoizedState),
+                ((instance$jscomp$0.props = current$$1.memoizedProps),
+                (instance$jscomp$0.state = current$$1.memoizedState),
                 commitUpdateQueue(
-                  current,
+                  current$$1,
                   updateQueue,
                   instance$jscomp$0,
                   prevProps
                 ));
               break;
             case 3:
-              var _updateQueue = current.updateQueue;
+              var _updateQueue = current$$1.updateQueue;
               if (null !== _updateQueue) {
                 prevState = null;
-                if (null !== current.child)
-                  switch (current.child.tag) {
+                if (null !== current$$1.child)
+                  switch (current$$1.child.tag) {
                     case 5:
-                      prevState = current.child.stateNode;
+                      prevState = current$$1.child.stateNode;
                       break;
                     case 2:
-                      prevState = current.child.stateNode;
+                      prevState = current$$1.child.stateNode;
                   }
-                commitUpdateQueue(current, _updateQueue, prevState, prevProps);
+                commitUpdateQueue(
+                  current$$1,
+                  _updateQueue,
+                  prevState,
+                  prevProps
+                );
               }
               break;
             case 5:
@@ -5351,18 +5526,20 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
           }
         }
         if (effectTag$jscomp$0 & 128) {
-          current = void 0;
+          current$$1 = void 0;
           var ref = nextEffect.ref;
           if (null !== ref) {
             var instance$jscomp$1 = nextEffect.stateNode;
             switch (nextEffect.tag) {
               case 5:
-                current = instance$jscomp$1;
+                current$$1 = instance$jscomp$1;
                 break;
               default:
-                current = instance$jscomp$1;
+                current$$1 = instance$jscomp$1;
             }
-            "function" === typeof ref ? ref(current) : (ref.current = current);
+            "function" === typeof ref
+              ? ref(current$$1)
+              : (ref.current = current$$1);
           }
         }
         var next = nextEffect.nextEffect;
@@ -5370,31 +5547,37 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = next;
       }
     } catch (e) {
-      (effectTag = !0), (current$jscomp$0 = e);
+      (effectTag = !0), (current$$1$jscomp$0 = e);
     }
     effectTag &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
       ),
-      captureCommitPhaseError(nextEffect, current$jscomp$0),
+      captureCommitPhaseError(nextEffect, current$$1$jscomp$0),
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
   isWorking = isCommitting$1 = !1;
-  "function" === typeof onCommitRoot &&
-    onCommitRoot(finishedWork$jscomp$0.stateNode);
-  finishedWork$jscomp$0 = root.expirationTime;
+  "function" === typeof onCommitFiberRoot &&
+    onCommitFiberRoot(finishedWork$jscomp$0.stateNode);
+  effectTag$jscomp$0 = finishedWork$jscomp$0.expirationTime;
+  finishedWork$jscomp$0 = finishedWork$jscomp$0.childExpirationTime;
+  finishedWork$jscomp$0 =
+    0 === effectTag$jscomp$0 ||
+    (0 !== finishedWork$jscomp$0 && finishedWork$jscomp$0 < effectTag$jscomp$0)
+      ? finishedWork$jscomp$0
+      : effectTag$jscomp$0;
   0 === finishedWork$jscomp$0 &&
     (legacyErrorBoundariesThatAlreadyFailed = null);
   root.expirationTime = finishedWork$jscomp$0;
   root.finishedWork = null;
 }
 function shouldYield() {
-  return null === deadline ||
-    deadlineDidExpire ||
-    deadline.timeRemaining() > timeHeuristicForUnitOfWork
-    ? !1
-    : (deadlineDidExpire = !0);
+  return deadlineDidExpire
+    ? !0
+    : null === deadline || deadline.timeRemaining() > timeHeuristicForUnitOfWork
+      ? !1
+      : (deadlineDidExpire = !0);
 }
 function onUncaughtError(error) {
   invariant(
@@ -5411,7 +5594,7 @@ function updateContainerAtExpirationTime(
   expirationTime,
   callback
 ) {
-  var current = container.current;
+  var current$$1 = container.current;
   if (parentComponent) {
     parentComponent = parentComponent._reactInternalFiber;
     var parentContext;
@@ -5437,7 +5620,7 @@ function updateContainerAtExpirationTime(
     parentComponent = isContextProvider(parentComponent)
       ? processChildContext(parentComponent, parentContext)
       : parentContext;
-  } else parentComponent = emptyObject;
+  } else parentComponent = emptyContextObject;
   null === container.context
     ? (container.context = parentComponent)
     : (container.pendingContext = parentComponent);
@@ -5446,8 +5629,8 @@ function updateContainerAtExpirationTime(
   callback.payload = { element: element };
   container = void 0 === container ? null : container;
   null !== container && (callback.callback = container);
-  enqueueUpdate(current, callback, expirationTime);
-  scheduleWork(current, expirationTime);
+  enqueueUpdate(current$$1, callback);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 function findHostInstance$1(component) {
@@ -5464,14 +5647,14 @@ function findHostInstance$1(component) {
   return null === component ? null : component.stateNode;
 }
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    currentTime = recalculateCurrentTime();
-  current = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current,
+    currentTime = requestCurrentTime();
+  current$$1 = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
     parentComponent,
-    current,
+    current$$1,
     callback
   );
 }
@@ -5514,14 +5697,12 @@ var ReactNativeFiberRenderer = {
     );
     nextFlushedRoot = root;
     nextFlushedExpirationTime = expirationTime;
-    performWorkOnRoot(root, expirationTime, !1);
+    performWorkOnRoot(root, expirationTime, !0);
     performWork(1, null);
-    finishRendering();
   },
   requestWork: requestWork,
   computeUniqueAsyncExpiration: function() {
-    var result =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var result = 2 + 25 * ((((requestCurrentTime() - 2 + 500) / 25) | 0) + 1);
     result <= lastUniqueAsyncExpiration &&
       (result = lastUniqueAsyncExpiration + 1);
     return (lastUniqueAsyncExpiration = result);
@@ -5549,9 +5730,9 @@ var ReactNativeFiberRenderer = {
     return fn(a);
   },
   deferredUpdates: function(fn) {
-    var previousExpirationContext = expirationContext;
-    expirationContext =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var currentTime = requestCurrentTime(),
+      previousExpirationContext = expirationContext;
+    expirationContext = 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1);
     try {
       return fn();
     } finally {
@@ -5723,7 +5904,7 @@ var roots = new Map(),
               maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
             nativeProps = diffProperties(
               null,
-              emptyObject$1,
+              emptyObject,
               nativeProps,
               viewConfig.validAttributes
             );
@@ -5799,7 +5980,7 @@ var roots = new Map(),
               var viewConfig = maybeInstance.viewConfig;
               nativeProps = diffProperties(
                 null,
-                emptyObject$1,
+                emptyObject,
                 nativeProps,
                 viewConfig.validAttributes
               );
@@ -5821,7 +6002,7 @@ var roots = new Map(),
       })(findNodeHandle, findHostInstance$1),
       computeComponentStackForErrorReporting: function(reactTag) {
         return (reactTag = getInstanceFromTag(reactTag))
-          ? getStackAddendumByWorkInProgressFiber(reactTag)
+          ? getStackByFiberInDevAndProd(reactTag)
           : "";
       }
     }
diff --git a/Libraries/Renderer/oss/ReactNativeRenderer-profiling.js b/Libraries/Renderer/oss/ReactNativeRenderer-profiling.js
index 1e2d9749c..8bc0925c1 100644
--- a/Libraries/Renderer/oss/ReactNativeRenderer-profiling.js
+++ b/Libraries/Renderer/oss/ReactNativeRenderer-profiling.js
@@ -12,16 +12,35 @@
 
 "use strict";
 require("InitializeCore");
-var invariant = require("fbjs/lib/invariant"),
-  ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
+var ReactNativeViewConfigRegistry = require("ReactNativeViewConfigRegistry"),
   UIManager = require("UIManager"),
   RCTEventEmitter = require("RCTEventEmitter"),
   React = require("react"),
-  emptyObject = require("fbjs/lib/emptyObject"),
   deepDiffer = require("deepDiffer"),
   flattenStyle = require("flattenStyle"),
   TextInputState = require("TextInputState"),
   ExceptionsManager = require("ExceptionsManager");
+function invariant(condition, format, a, b, c, d, e, f) {
+  if (!condition) {
+    condition = void 0;
+    if (void 0 === format)
+      condition = Error(
+        "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+      );
+    else {
+      var args = [a, b, c, d, e, f],
+        argIndex = 0;
+      condition = Error(
+        format.replace(/%s/g, function() {
+          return args[argIndex++];
+        })
+      );
+      condition.name = "Invariant Violation";
+    }
+    condition.framesToPop = 1;
+    throw condition;
+  }
+}
 function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
   this._hasCaughtError = !1;
   this._caughtError = null;
@@ -347,9 +366,6 @@ function accumulateDirectDispatchesSingle(event) {
     }
   }
 }
-var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(
-  " "
-);
 function functionThatReturnsTrue() {
   return !0;
 }
@@ -407,12 +423,9 @@ Object.assign(SyntheticEvent.prototype, {
     var Interface = this.constructor.Interface,
       propName;
     for (propName in Interface) this[propName] = null;
-    for (
-      Interface = 0;
-      Interface < shouldBeReleasedProperties.length;
-      Interface++
-    )
-      this[shouldBeReleasedProperties[Interface]] = null;
+    this.nativeEvent = this._targetInst = this.dispatchConfig = null;
+    this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
+    this._dispatchInstances = this._dispatchListeners = null;
   }
 });
 SyntheticEvent.Interface = {
@@ -458,7 +471,7 @@ function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
 function releasePooledEvent(event) {
   invariant(
     event instanceof this,
-    "Trying to release an event instance  into a pool of a different type."
+    "Trying to release an event instance into a pool of a different type."
   );
   event.destructor();
   10 > this.eventPool.length && this.eventPool.push(event);
@@ -615,7 +628,9 @@ function accumulate(current, next) {
     ? next
     : Array.isArray(current)
       ? current.concat(next)
-      : Array.isArray(next) ? [current].concat(next) : [current, next];
+      : Array.isArray(next)
+        ? [current].concat(next)
+        : [current, next];
 }
 var responderInst = null,
   trackedTouchCount = 0;
@@ -881,7 +896,9 @@ var eventTypes$1 = {
           ? eventTypes$1.responderStart
           : targetInst
             ? eventTypes$1.responderMove
-            : depthA ? eventTypes$1.responderEnd : null)
+            : depthA
+              ? eventTypes$1.responderEnd
+              : null)
       )
         (JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(
           JSCompiler_temp$jscomp$0,
@@ -935,7 +952,9 @@ var eventTypes$1 = {
       if (
         (topLevelType = JSCompiler_temp$jscomp$0
           ? eventTypes$1.responderTerminate
-          : topLevelType ? eventTypes$1.responderRelease : null)
+          : topLevelType
+            ? eventTypes$1.responderRelease
+            : null)
       )
         (nativeEvent = ResponderSyntheticEvent.getPooled(
           topLevelType,
@@ -1145,8 +1164,8 @@ ResponderEventPlugin.injection.injectGlobalResponderHandler({
       : UIManager.clearJSResponder();
   }
 });
-var ReactCurrentOwner =
-    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
+var ReactSharedInternals =
+    React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
   hasSymbol = "function" === typeof Symbol && Symbol.for,
   REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103,
   REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106,
@@ -1157,7 +1176,7 @@ var ReactCurrentOwner =
   REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110,
   REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111,
   REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112,
-  REACT_TIMEOUT_TYPE = hasSymbol ? Symbol.for("react.timeout") : 60113,
+  REACT_PLACEHOLDER_TYPE = hasSymbol ? Symbol.for("react.placeholder") : 60113,
   MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && Symbol.iterator;
 function getIteratorFn(maybeIterable) {
   if (null === maybeIterable || "undefined" === typeof maybeIterable)
@@ -1167,34 +1186,35 @@ function getIteratorFn(maybeIterable) {
     maybeIterable["@@iterator"];
   return "function" === typeof maybeIterable ? maybeIterable : null;
 }
-function getComponentName(fiber) {
-  var type = fiber.type;
-  if ("function" === typeof type) return type.displayName || type.name;
+function getComponentName(type) {
+  if (null == type) return null;
+  if ("function" === typeof type) return type.displayName || type.name || null;
   if ("string" === typeof type) return type;
   switch (type) {
     case REACT_ASYNC_MODE_TYPE:
       return "AsyncMode";
-    case REACT_CONTEXT_TYPE:
-      return "Context.Consumer";
     case REACT_FRAGMENT_TYPE:
-      return "ReactFragment";
+      return "Fragment";
     case REACT_PORTAL_TYPE:
-      return "ReactPortal";
+      return "Portal";
     case REACT_PROFILER_TYPE:
-      return "Profiler(" + fiber.pendingProps.id + ")";
-    case REACT_PROVIDER_TYPE:
-      return "Context.Provider";
+      return "Profiler";
     case REACT_STRICT_MODE_TYPE:
       return "StrictMode";
-    case REACT_TIMEOUT_TYPE:
-      return "Timeout";
+    case REACT_PLACEHOLDER_TYPE:
+      return "Placeholder";
   }
-  if ("object" === typeof type && null !== type)
+  if ("object" === typeof type)
     switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        return "Context.Consumer";
+      case REACT_PROVIDER_TYPE:
+        return "Context.Provider";
       case REACT_FORWARD_REF_TYPE:
         return (
-          (fiber = type.render.displayName || type.render.name || ""),
-          "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef"
+          (type = type.render),
+          (type = type.displayName || type.name || ""),
+          "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"
         );
     }
   return null;
@@ -1323,7 +1343,7 @@ function findCurrentHostFiberWithNoPortals(parent) {
   }
   return null;
 }
-var emptyObject$1 = {},
+var emptyObject = {},
   removedKeys = null,
   removedKeyCount = 0;
 function restoreDeletedValuesInNestedArray(
@@ -1423,7 +1443,7 @@ function addNestedProperty(updatePayload, nextProp, validAttributes) {
   if (!Array.isArray(nextProp))
     return diffProperties(
       updatePayload,
-      emptyObject$1,
+      emptyObject,
       nextProp,
       validAttributes
     );
@@ -1441,7 +1461,7 @@ function clearNestedProperty(updatePayload, prevProp, validAttributes) {
     return diffProperties(
       updatePayload,
       prevProp,
-      emptyObject$1,
+      emptyObject,
       validAttributes
     );
   for (var i = 0; i < prevProp.length; i++)
@@ -1597,7 +1617,7 @@ var ReactNativeFiberHostComponent = (function() {
     ) {
       nativeProps = diffProperties(
         null,
-        emptyObject$1,
+        emptyObject,
         nativeProps,
         this.viewConfig.validAttributes
       );
@@ -1638,7 +1658,8 @@ function shim$1() {
     "The current renderer does not support hyration. This error is likely caused by a bug in React. Please file an issue."
   );
 }
-var nextReactTag = 3;
+var UPDATE_SIGNAL = {},
+  nextReactTag = 3;
 function allocateTag() {
   var tag = nextReactTag;
   1 === tag % 10 && (tag += 2);
@@ -1659,7 +1680,7 @@ function finalizeInitialChildren(parentInstance) {
   UIManager.setChildren(parentInstance._nativeTag, nativeTags);
   return !1;
 }
-function getStackAddendumByWorkInProgressFiber(workInProgress) {
+function getStackByFiberInDevAndProd(workInProgress) {
   var info = "";
   do {
     a: switch (workInProgress.tag) {
@@ -1667,11 +1688,12 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
       case 1:
       case 2:
       case 5:
+      case 11:
         var owner = workInProgress._debugOwner,
           source = workInProgress._debugSource;
-        var JSCompiler_inline_result = getComponentName(workInProgress);
+        var JSCompiler_inline_result = getComponentName(workInProgress.type);
         var ownerName = null;
-        owner && (ownerName = getComponentName(owner));
+        owner && (ownerName = getComponentName(owner.type));
         owner = source;
         JSCompiler_inline_result =
           "\n    in " +
@@ -1682,7 +1704,9 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
               ":" +
               owner.lineNumber +
               ")"
-            : ownerName ? " (created by " + ownerName + ")" : "");
+            : ownerName
+              ? " (created by " + ownerName + ")"
+              : "");
         break a;
       default:
         JSCompiler_inline_result = "";
@@ -1695,9 +1719,6 @@ function getStackAddendumByWorkInProgressFiber(workInProgress) {
 new Set();
 var valueStack = [],
   index = -1;
-function createCursor(defaultValue) {
-  return { current: defaultValue };
-}
 function pop(cursor) {
   0 > index ||
     ((cursor.current = valueStack[index]), (valueStack[index] = null), index--);
@@ -1707,9 +1728,10 @@ function push(cursor, value) {
   valueStack[index] = cursor.current;
   cursor.current = value;
 }
-var contextStackCursor = createCursor(emptyObject),
-  didPerformWorkStackCursor = createCursor(!1),
-  previousContext = emptyObject;
+var emptyContextObject = {},
+  contextStackCursor = { current: emptyContextObject },
+  didPerformWorkStackCursor = { current: !1 },
+  previousContext = emptyContextObject;
 function getUnmaskedContext(workInProgress) {
   return isContextProvider(workInProgress)
     ? previousContext
@@ -1717,7 +1739,7 @@ function getUnmaskedContext(workInProgress) {
 }
 function getMaskedContext(workInProgress, unmaskedContext) {
   var contextTypes = workInProgress.type.contextTypes;
-  if (!contextTypes) return emptyObject;
+  if (!contextTypes) return emptyContextObject;
   var instance = workInProgress.stateNode;
   if (
     instance &&
@@ -1746,15 +1768,16 @@ function popTopLevelContextObject(fiber) {
 }
 function pushTopLevelContextObject(fiber, context, didChange) {
   invariant(
-    contextStackCursor.current === emptyObject,
+    contextStackCursor.current === emptyContextObject,
     "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(fiber, parentContext) {
-  var instance = fiber.stateNode,
-    childContextTypes = fiber.type.childContextTypes;
+  var instance = fiber.stateNode;
+  fiber = fiber.type;
+  var childContextTypes = fiber.childContextTypes;
   if ("function" !== typeof instance.getChildContext) return parentContext;
   instance = instance.getChildContext();
   for (var contextKey in instance)
@@ -1771,7 +1794,7 @@ function pushContextProvider(workInProgress) {
   var instance = workInProgress.stateNode;
   instance =
     (instance && instance.__reactInternalMemoizedMergedChildContext) ||
-    emptyObject;
+    emptyContextObject;
   previousContext = contextStackCursor.current;
   push(contextStackCursor, instance, workInProgress);
   push(
@@ -1796,6 +1819,31 @@ function invalidateContextProvider(workInProgress, didChange) {
   } else pop(didPerformWorkStackCursor, workInProgress);
   push(didPerformWorkStackCursor, didChange, workInProgress);
 }
+var onCommitFiberRoot = null,
+  onCommitFiberUnmount = null;
+function catchErrors(fn) {
+  return function(arg) {
+    try {
+      return fn(arg);
+    } catch (err) {}
+  };
+}
+var isDevToolsPresent = "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__;
+function injectInternals(internals) {
+  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
+  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook.isDisabled || !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 FiberNode(tag, pendingProps, key, mode) {
   this.tag = tag;
   this.key = key;
@@ -1803,13 +1851,13 @@ function FiberNode(tag, pendingProps, key, mode) {
   this.index = 0;
   this.ref = null;
   this.pendingProps = pendingProps;
-  this.memoizedState = this.updateQueue = this.memoizedProps = null;
+  this.firstContextDependency = this.memoizedState = this.updateQueue = this.memoizedProps = null;
   this.mode = mode;
   this.effectTag = 0;
   this.lastEffect = this.firstEffect = this.nextEffect = null;
-  this.expirationTime = 0;
+  this.childExpirationTime = this.expirationTime = 0;
   this.alternate = null;
-  this.treeBaseTime = this.selfBaseTime = this.actualStartTime = this.actualDuration = 0;
+  this.treeBaseDuration = this.selfBaseDuration = this.actualStartTime = this.actualDuration = 0;
 }
 function createWorkInProgress(current, pendingProps, expirationTime) {
   var workInProgress = current.alternate;
@@ -1831,16 +1879,21 @@ function createWorkInProgress(current, pendingProps, expirationTime) {
       (workInProgress.lastEffect = null),
       (workInProgress.actualDuration = 0),
       (workInProgress.actualStartTime = 0));
-  workInProgress.expirationTime = expirationTime;
+  workInProgress.childExpirationTime = current.childExpirationTime;
+  workInProgress.expirationTime =
+    pendingProps !== current.pendingProps
+      ? expirationTime
+      : current.expirationTime;
   workInProgress.child = current.child;
   workInProgress.memoizedProps = current.memoizedProps;
   workInProgress.memoizedState = current.memoizedState;
   workInProgress.updateQueue = current.updateQueue;
+  workInProgress.firstContextDependency = current.firstContextDependency;
   workInProgress.sibling = current.sibling;
   workInProgress.index = current.index;
   workInProgress.ref = current.ref;
-  workInProgress.selfBaseTime = current.selfBaseTime;
-  workInProgress.treeBaseTime = current.treeBaseTime;
+  workInProgress.selfBaseDuration = current.selfBaseDuration;
+  workInProgress.treeBaseDuration = current.treeBaseDuration;
   return workInProgress;
 }
 function createFiberFromElement(element, mode, expirationTime) {
@@ -1874,15 +1927,14 @@ function createFiberFromElement(element, mode, expirationTime) {
           (type.expirationTime = expirationTime),
           type
         );
-      case REACT_TIMEOUT_TYPE:
+      case REACT_PLACEHOLDER_TYPE:
         fiberTag = 16;
-        mode |= 2;
         break;
       default:
         a: {
-          switch ("object" === typeof type && null !== type
-            ? type.$$typeof
-            : null) {
+          switch (
+            "object" === typeof type && null !== type ? type.$$typeof : null
+          ) {
             case REACT_PROVIDER_TYPE:
               fiberTag = 13;
               break a;
@@ -1934,7 +1986,9 @@ function createFiberFromPortal(portal, mode, expirationTime) {
   return mode;
 }
 function createFiberRoot(containerInfo, isAsync, hydrate) {
-  isAsync = new FiberNode(3, null, null, isAsync ? 3 : 0);
+  isAsync = isAsync ? 3 : 0;
+  isDevToolsPresent && (isAsync |= 4);
+  isAsync = new FiberNode(3, null, null, isAsync);
   containerInfo = {
     current: isAsync,
     containerInfo: containerInfo,
@@ -1947,6 +2001,7 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
     didError: !1,
     pendingCommitExpirationTime: 0,
     finishedWork: null,
+    timeoutHandle: -1,
     context: null,
     pendingContext: null,
     hydrate: hydrate,
@@ -1957,36 +2012,6 @@ function createFiberRoot(containerInfo, isAsync, hydrate) {
   };
   return (isAsync.stateNode = containerInfo);
 }
-var onCommitFiberRoot = null,
-  onCommitFiberUnmount = null;
-function catchErrors(fn) {
-  return function(arg) {
-    try {
-      return fn(arg);
-    } catch (err) {}
-  };
-}
-function injectInternals(internals) {
-  if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
-  var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-  if (hook.isDisabled || !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(root) {
-  "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
-}
-function onCommitUnmount(fiber) {
-  "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
-}
 function markPendingPriorityLevel(root, expirationTime) {
   root.didError = !1;
   var earliestPendingTime = root.earliestPendingTime;
@@ -1996,30 +2021,30 @@ function markPendingPriorityLevel(root, expirationTime) {
       ? (root.earliestPendingTime = expirationTime)
       : root.latestPendingTime < expirationTime &&
         (root.latestPendingTime = expirationTime);
-  findNextPendingPriorityLevel(root);
+  findNextExpirationTimeToWorkOn(expirationTime, root);
 }
-function findNextPendingPriorityLevel(root) {
+function findNextExpirationTimeToWorkOn(completedExpirationTime, root) {
   var earliestSuspendedTime = root.earliestSuspendedTime,
-    earliestPendingTime = root.earliestPendingTime;
-  if (0 === earliestSuspendedTime)
-    var nextExpirationTimeToWorkOn = (earliestSuspendedTime = earliestPendingTime);
-  else
-    0 !== earliestPendingTime
-      ? ((nextExpirationTimeToWorkOn = earliestPendingTime),
-        (earliestSuspendedTime =
-          earliestSuspendedTime < earliestPendingTime
-            ? earliestSuspendedTime
-            : earliestPendingTime))
-      : (nextExpirationTimeToWorkOn = earliestSuspendedTime =
-          root.latestPingedTime);
-  root.didError && (earliestSuspendedTime = 1);
-  root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
-  root.expirationTime = earliestSuspendedTime;
+    latestSuspendedTime = root.latestSuspendedTime,
+    earliestPendingTime = root.earliestPendingTime,
+    latestPingedTime = root.latestPingedTime;
+  earliestPendingTime =
+    0 !== earliestPendingTime ? earliestPendingTime : latestPingedTime;
+  0 === earliestPendingTime &&
+    (0 === completedExpirationTime ||
+      latestSuspendedTime > completedExpirationTime) &&
+    (earliestPendingTime = latestSuspendedTime);
+  completedExpirationTime = earliestPendingTime;
+  0 !== completedExpirationTime &&
+    0 !== earliestSuspendedTime &&
+    earliestSuspendedTime < completedExpirationTime &&
+    (completedExpirationTime = earliestSuspendedTime);
+  root.nextExpirationTimeToWorkOn = earliestPendingTime;
+  root.expirationTime = completedExpirationTime;
 }
 var hasForceUpdate = !1;
 function createUpdateQueue(baseState) {
   return {
-    expirationTime: 0,
     baseState: baseState,
     firstUpdate: null,
     lastUpdate: null,
@@ -2033,7 +2058,6 @@ function createUpdateQueue(baseState) {
 }
 function cloneUpdateQueue(currentQueue) {
   return {
-    expirationTime: currentQueue.expirationTime,
     baseState: currentQueue.baseState,
     firstUpdate: currentQueue.firstUpdate,
     lastUpdate: currentQueue.lastUpdate,
@@ -2055,14 +2079,12 @@ function createUpdate(expirationTime) {
     nextEffect: null
   };
 }
-function appendUpdateToQueue(queue, update, expirationTime) {
+function appendUpdateToQueue(queue, update) {
   null === queue.lastUpdate
     ? (queue.firstUpdate = queue.lastUpdate = update)
     : ((queue.lastUpdate.next = update), (queue.lastUpdate = update));
-  if (0 === queue.expirationTime || queue.expirationTime > expirationTime)
-    queue.expirationTime = expirationTime;
 }
-function enqueueUpdate(fiber, update, expirationTime) {
+function enqueueUpdate(fiber, update) {
   var alternate = fiber.alternate;
   if (null === alternate) {
     var queue1 = fiber.updateQueue;
@@ -2084,14 +2106,13 @@ function enqueueUpdate(fiber, update, expirationTime) {
         : null === queue2 &&
           (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));
   null === queue2 || queue1 === queue2
-    ? appendUpdateToQueue(queue1, update, expirationTime)
+    ? appendUpdateToQueue(queue1, update)
     : null === queue1.lastUpdate || null === queue2.lastUpdate
-      ? (appendUpdateToQueue(queue1, update, expirationTime),
-        appendUpdateToQueue(queue2, update, expirationTime))
-      : (appendUpdateToQueue(queue1, update, expirationTime),
-        (queue2.lastUpdate = update));
+      ? (appendUpdateToQueue(queue1, update),
+        appendUpdateToQueue(queue2, update))
+      : (appendUpdateToQueue(queue1, update), (queue2.lastUpdate = update));
 }
-function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
+function enqueueCapturedUpdate(workInProgress, update) {
   var workInProgressQueue = workInProgress.updateQueue;
   workInProgressQueue =
     null === workInProgressQueue
@@ -2103,11 +2124,6 @@ function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
     ? (workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update)
     : ((workInProgressQueue.lastCapturedUpdate.next = update),
       (workInProgressQueue.lastCapturedUpdate = update));
-  if (
-    0 === workInProgressQueue.expirationTime ||
-    workInProgressQueue.expirationTime > renderExpirationTime
-  )
-    workInProgressQueue.expirationTime = renderExpirationTime;
 }
 function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
   var current = workInProgress.alternate;
@@ -2155,87 +2171,83 @@ function processUpdateQueue(
   renderExpirationTime
 ) {
   hasForceUpdate = !1;
-  if (
-    !(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)
-  ) {
-    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
-    for (
-      var newBaseState = queue.baseState,
-        newFirstUpdate = null,
-        newExpirationTime = 0,
-        update = queue.firstUpdate,
-        resultState = newBaseState;
-      null !== update;
+  queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
+  for (
+    var newBaseState = queue.baseState,
+      newFirstUpdate = null,
+      newExpirationTime = 0,
+      update = queue.firstUpdate,
+      resultState = newBaseState;
+    null !== update;
 
-    ) {
-      var updateExpirationTime = update.expirationTime;
-      if (updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === newFirstUpdate &&
-            ((newFirstUpdate = update), (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > updateExpirationTime)
-        )
-          newExpirationTime = updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastEffect
-              ? (queue.firstEffect = queue.lastEffect = update)
-              : ((queue.lastEffect.nextEffect = update),
-                (queue.lastEffect = update)));
-      update = update.next;
-    }
-    updateExpirationTime = null;
-    for (update = queue.firstCapturedUpdate; null !== update; ) {
-      var _updateExpirationTime = update.expirationTime;
-      if (_updateExpirationTime > renderExpirationTime) {
-        if (
-          (null === updateExpirationTime &&
-            ((updateExpirationTime = update),
-            null === newFirstUpdate && (newBaseState = resultState)),
-          0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
-        )
-          newExpirationTime = _updateExpirationTime;
-      } else
-        (resultState = getStateFromUpdate(
-          workInProgress,
-          queue,
-          update,
-          resultState,
-          props,
-          instance
-        )),
-          null !== update.callback &&
-            ((workInProgress.effectTag |= 32),
-            (update.nextEffect = null),
-            null === queue.lastCapturedEffect
-              ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
-              : ((queue.lastCapturedEffect.nextEffect = update),
-                (queue.lastCapturedEffect = update)));
-      update = update.next;
-    }
-    null === newFirstUpdate && (queue.lastUpdate = null);
-    null === updateExpirationTime
-      ? (queue.lastCapturedUpdate = null)
-      : (workInProgress.effectTag |= 32);
-    null === newFirstUpdate &&
-      null === updateExpirationTime &&
-      (newBaseState = resultState);
-    queue.baseState = newBaseState;
-    queue.firstUpdate = newFirstUpdate;
-    queue.firstCapturedUpdate = updateExpirationTime;
-    queue.expirationTime = newExpirationTime;
-    workInProgress.memoizedState = resultState;
+  ) {
+    var updateExpirationTime = update.expirationTime;
+    if (updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === newFirstUpdate &&
+          ((newFirstUpdate = update), (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > updateExpirationTime)
+      )
+        newExpirationTime = updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastEffect
+            ? (queue.firstEffect = queue.lastEffect = update)
+            : ((queue.lastEffect.nextEffect = update),
+              (queue.lastEffect = update)));
+    update = update.next;
   }
+  updateExpirationTime = null;
+  for (update = queue.firstCapturedUpdate; null !== update; ) {
+    var _updateExpirationTime = update.expirationTime;
+    if (_updateExpirationTime > renderExpirationTime) {
+      if (
+        (null === updateExpirationTime &&
+          ((updateExpirationTime = update),
+          null === newFirstUpdate && (newBaseState = resultState)),
+        0 === newExpirationTime || newExpirationTime > _updateExpirationTime)
+      )
+        newExpirationTime = _updateExpirationTime;
+    } else
+      (resultState = getStateFromUpdate(
+        workInProgress,
+        queue,
+        update,
+        resultState,
+        props,
+        instance
+      )),
+        null !== update.callback &&
+          ((workInProgress.effectTag |= 32),
+          (update.nextEffect = null),
+          null === queue.lastCapturedEffect
+            ? (queue.firstCapturedEffect = queue.lastCapturedEffect = update)
+            : ((queue.lastCapturedEffect.nextEffect = update),
+              (queue.lastCapturedEffect = update)));
+    update = update.next;
+  }
+  null === newFirstUpdate && (queue.lastUpdate = null);
+  null === updateExpirationTime
+    ? (queue.lastCapturedUpdate = null)
+    : (workInProgress.effectTag |= 32);
+  null === newFirstUpdate &&
+    null === updateExpirationTime &&
+    (newBaseState = resultState);
+  queue.baseState = newBaseState;
+  queue.firstUpdate = newFirstUpdate;
+  queue.firstCapturedUpdate = updateExpirationTime;
+  workInProgress.expirationTime = newExpirationTime;
+  workInProgress.memoizedState = resultState;
 }
 function callCallback(callback, context) {
   invariant(
@@ -2277,34 +2289,153 @@ function createCapturedValue(value, source) {
   return {
     value: value,
     source: source,
-    stack: getStackAddendumByWorkInProgressFiber(source)
+    stack: getStackByFiberInDevAndProd(source)
   };
 }
-var providerCursor = createCursor(null),
-  valueCursor = createCursor(null),
-  changedBitsCursor = createCursor(0);
+var valueCursor = { current: null },
+  changedBitsCursor = { current: 0 },
+  currentlyRenderingFiber = null,
+  lastContextDependency = null,
+  lastContextWithAllBitsObserved = null;
 function pushProvider(providerFiber) {
   var context = providerFiber.type._context;
   push(changedBitsCursor, context._changedBits, providerFiber);
   push(valueCursor, context._currentValue, providerFiber);
-  push(providerCursor, providerFiber, providerFiber);
   context._currentValue = providerFiber.pendingProps.value;
   context._changedBits = providerFiber.stateNode;
 }
 function popProvider(providerFiber) {
   var changedBits = changedBitsCursor.current,
     currentValue = valueCursor.current;
-  pop(providerCursor, providerFiber);
   pop(valueCursor, providerFiber);
   pop(changedBitsCursor, providerFiber);
   providerFiber = providerFiber.type._context;
   providerFiber._currentValue = currentValue;
   providerFiber._changedBits = changedBits;
 }
+function propagateContextChange(
+  workInProgress,
+  context,
+  changedBits,
+  renderExpirationTime
+) {
+  var fiber = workInProgress.child;
+  null !== fiber && (fiber.return = workInProgress);
+  for (; null !== fiber; ) {
+    var dependency = fiber.firstContextDependency;
+    if (null !== dependency) {
+      do {
+        if (
+          dependency.context === context &&
+          0 !== (dependency.observedBits & changedBits)
+        ) {
+          if (
+            0 === fiber.expirationTime ||
+            fiber.expirationTime > renderExpirationTime
+          )
+            fiber.expirationTime = renderExpirationTime;
+          var nextFiber = fiber.alternate;
+          null !== nextFiber &&
+            (0 === nextFiber.expirationTime ||
+              nextFiber.expirationTime > renderExpirationTime) &&
+            (nextFiber.expirationTime = renderExpirationTime);
+          for (var node = fiber.return; null !== node; ) {
+            nextFiber = node.alternate;
+            if (
+              0 === node.childExpirationTime ||
+              node.childExpirationTime > renderExpirationTime
+            )
+              (node.childExpirationTime = renderExpirationTime),
+                null !== nextFiber &&
+                  (0 === nextFiber.childExpirationTime ||
+                    nextFiber.childExpirationTime > renderExpirationTime) &&
+                  (nextFiber.childExpirationTime = renderExpirationTime);
+            else if (
+              null !== nextFiber &&
+              (0 === nextFiber.childExpirationTime ||
+                nextFiber.childExpirationTime > renderExpirationTime)
+            )
+              nextFiber.childExpirationTime = renderExpirationTime;
+            else break;
+            node = node.return;
+          }
+          nextFiber = null;
+        } else nextFiber = fiber.child;
+        dependency = dependency.next;
+      } while (null !== dependency);
+    } else
+      nextFiber =
+        13 === fiber.tag
+          ? fiber.type === workInProgress.type
+            ? null
+            : fiber.child
+          : fiber.child;
+    if (null !== nextFiber) nextFiber.return = fiber;
+    else
+      for (nextFiber = fiber; null !== nextFiber; ) {
+        if (nextFiber === workInProgress) {
+          nextFiber = null;
+          break;
+        }
+        fiber = nextFiber.sibling;
+        if (null !== fiber) {
+          fiber.return = nextFiber.return;
+          nextFiber = fiber;
+          break;
+        }
+        nextFiber = nextFiber.return;
+      }
+    fiber = nextFiber;
+  }
+}
+function prepareToReadContext(workInProgress, renderExpirationTime) {
+  currentlyRenderingFiber = workInProgress;
+  lastContextWithAllBitsObserved = lastContextDependency = null;
+  var firstContextDependency = workInProgress.firstContextDependency;
+  if (null !== firstContextDependency) {
+    workInProgress.firstContextDependency = null;
+    var hasPendingContext = !1;
+    do {
+      var _context = firstContextDependency.context,
+        changedBits = _context._changedBits;
+      0 !== changedBits &&
+        (propagateContextChange(
+          workInProgress,
+          _context,
+          changedBits,
+          renderExpirationTime
+        ),
+        0 !== (changedBits & firstContextDependency.observedBits) &&
+          (hasPendingContext = !0));
+      firstContextDependency = firstContextDependency.next;
+    } while (null !== firstContextDependency);
+    return hasPendingContext;
+  }
+  return !1;
+}
+function readContext(context, observedBits) {
+  if (
+    lastContextWithAllBitsObserved !== context &&
+    !1 !== observedBits &&
+    0 !== observedBits
+  ) {
+    if ("number" !== typeof observedBits || 1073741823 === observedBits)
+      (lastContextWithAllBitsObserved = context), (observedBits = 1073741823);
+    observedBits = { context: context, observedBits: observedBits, next: null };
+    null === lastContextDependency
+      ? (invariant(
+          null !== currentlyRenderingFiber,
+          "Context.unstable_read(): Context can only be read while React is rendering, e.g. inside the render method or getDerivedStateFromProps."
+        ),
+        (currentlyRenderingFiber.firstContextDependency = lastContextDependency = observedBits))
+      : (lastContextDependency = lastContextDependency.next = observedBits);
+  }
+  return context._currentValue;
+}
 var NO_CONTEXT = {},
-  contextStackCursor$1 = createCursor(NO_CONTEXT),
-  contextFiberStackCursor = createCursor(NO_CONTEXT),
-  rootInstanceStackCursor = createCursor(NO_CONTEXT);
+  contextStackCursor$1 = { current: NO_CONTEXT },
+  contextFiberStackCursor = { current: NO_CONTEXT },
+  rootInstanceStackCursor = { current: NO_CONTEXT };
 function requiredContext(c) {
   invariant(
     c !== NO_CONTEXT,
@@ -2324,17 +2455,46 @@ function popHostContainer(fiber) {
   pop(contextFiberStackCursor, fiber);
   pop(rootInstanceStackCursor, fiber);
 }
+function pushHostContext(fiber) {
+  requiredContext(rootInstanceStackCursor.current);
+  var context = requiredContext(contextStackCursor$1.current);
+  var nextContext = fiber.type;
+  nextContext =
+    "AndroidTextInput" === nextContext ||
+    "RCTMultilineTextInputView" === nextContext ||
+    "RCTSinglelineTextInputView" === nextContext ||
+    "RCTText" === nextContext ||
+    "RCTVirtualText" === nextContext;
+  nextContext =
+    context.isInAParentText !== nextContext
+      ? { isInAParentText: nextContext }
+      : context;
+  context !== nextContext &&
+    (push(contextFiberStackCursor, fiber, fiber),
+    push(contextStackCursor$1, nextContext, fiber));
+}
 function popHostContext(fiber) {
   contextFiberStackCursor.current === fiber &&
     (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
 }
 var commitTime = 0,
+  syncCommitStartTime = 0,
   timerPausedAt = 0,
   totalElapsedPauseTime = 0;
+function pauseActualRenderTimerIfRunning() {
+  0 === timerPausedAt && (timerPausedAt = now$1());
+  0 < syncCommitStartTime
+    ? ((totalElapsedPauseTime += now$1() - syncCommitStartTime),
+      (syncCommitStartTime = 0))
+    : (totalElapsedPauseTime = 0);
+}
 function recordElapsedActualRenderTime(fiber) {
   fiber.actualDuration = now$1() - totalElapsedPauseTime - fiber.actualDuration;
 }
-function resumeActualRenderTimerIfPaused() {
+function resumeActualRenderTimerIfPaused(isProcessingSyncWork) {
+  isProcessingSyncWork &&
+    0 === syncCommitStartTime &&
+    (syncCommitStartTime = now$1());
   0 < timerPausedAt &&
     ((totalElapsedPauseTime += now$1() - timerPausedAt), (timerPausedAt = 0));
 }
@@ -2363,6 +2523,7 @@ function shallowEqual(objA, objB) {
       return !1;
   return !0;
 }
+var emptyRefsObject = new React.Component().refs;
 function applyDerivedStateFromProps(
   workInProgress,
   getDerivedStateFromProps,
@@ -2375,10 +2536,10 @@ function applyDerivedStateFromProps(
       ? prevState
       : Object.assign({}, prevState, getDerivedStateFromProps);
   workInProgress.memoizedState = prevState;
-  workInProgress = workInProgress.updateQueue;
-  null !== workInProgress &&
+  getDerivedStateFromProps = workInProgress.updateQueue;
+  null !== getDerivedStateFromProps &&
     0 === workInProgress.expirationTime &&
-    (workInProgress.baseState = prevState);
+    (getDerivedStateFromProps.baseState = prevState);
 }
 var classComponentUpdater = {
   isMounted: function(component) {
@@ -2388,33 +2549,33 @@ var classComponentUpdater = {
   },
   enqueueSetState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueReplaceState: function(inst, payload, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 1;
     update.payload = payload;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   },
   enqueueForceUpdate: function(inst, callback) {
     inst = inst._reactInternalFiber;
-    var currentTime = recalculateCurrentTime();
+    var currentTime = requestCurrentTime();
     currentTime = computeExpirationForFiber(currentTime, inst);
     var update = createUpdate(currentTime);
     update.tag = 2;
     void 0 !== callback && null !== callback && (update.callback = callback);
-    enqueueUpdate(inst, update, currentTime);
+    enqueueUpdate(inst, update);
     scheduleWork(inst, currentTime);
   }
 };
@@ -2424,12 +2585,12 @@ function checkShouldComponentUpdate(
   newProps,
   oldState,
   newState,
-  newContext
+  nextLegacyContext
 ) {
   var instance = workInProgress.stateNode;
   workInProgress = workInProgress.type;
   return "function" === typeof instance.shouldComponentUpdate
-    ? instance.shouldComponentUpdate(newProps, newState, newContext)
+    ? instance.shouldComponentUpdate(newProps, newState, nextLegacyContext)
     : workInProgress.prototype && workInProgress.prototype.isPureReactComponent
       ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState)
       : !0;
@@ -2438,13 +2599,13 @@ function callComponentWillReceiveProps(
   workInProgress,
   instance,
   newProps,
-  newContext
+  nextLegacyContext
 ) {
   workInProgress = instance.state;
   "function" === typeof instance.componentWillReceiveProps &&
-    instance.componentWillReceiveProps(newProps, newContext);
+    instance.componentWillReceiveProps(newProps, nextLegacyContext);
   "function" === typeof instance.UNSAFE_componentWillReceiveProps &&
-    instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
+    instance.UNSAFE_componentWillReceiveProps(newProps, nextLegacyContext);
   instance.state !== workInProgress &&
     classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
 }
@@ -2455,7 +2616,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     unmaskedContext = getUnmaskedContext(workInProgress);
   instance.props = props;
   instance.state = workInProgress.memoizedState;
-  instance.refs = emptyObject;
+  instance.refs = emptyRefsObject;
   instance.context = getMaskedContext(workInProgress, unmaskedContext);
   unmaskedContext = workInProgress.updateQueue;
   null !== unmaskedContext &&
@@ -2467,7 +2628,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
       renderExpirationTime
     ),
     (instance.state = workInProgress.memoizedState));
-  unmaskedContext = workInProgress.type.getDerivedStateFromProps;
+  unmaskedContext = ctor.getDerivedStateFromProps;
   "function" === typeof unmaskedContext &&
     (applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
     (instance.state = workInProgress.memoizedState));
@@ -2496,7 +2657,7 @@ function mountClassInstance(workInProgress, renderExpirationTime) {
     (workInProgress.effectTag |= 4);
 }
 var isArray$1 = Array.isArray;
-function coerceRef(returnFiber, current, element) {
+function coerceRef(returnFiber, current$$1, element) {
   returnFiber = element.ref;
   if (
     null !== returnFiber &&
@@ -2519,18 +2680,19 @@ function coerceRef(returnFiber, current, element) {
       );
       var stringRef = "" + returnFiber;
       if (
-        null !== current &&
-        null !== current.ref &&
-        "function" === typeof current.ref &&
-        current.ref._stringRef === stringRef
+        null !== current$$1 &&
+        null !== current$$1.ref &&
+        "function" === typeof current$$1.ref &&
+        current$$1.ref._stringRef === stringRef
       )
-        return current.ref;
-      current = function(value) {
-        var refs = inst.refs === emptyObject ? (inst.refs = {}) : inst.refs;
+        return current$$1.ref;
+      current$$1 = function(value) {
+        var refs = inst.refs;
+        refs === emptyRefsObject && (refs = inst.refs = {});
         null === value ? delete refs[stringRef] : (refs[stringRef] = value);
       };
-      current._stringRef = stringRef;
-      return current;
+      current$$1._stringRef = stringRef;
+      return current$$1;
     }
     invariant(
       "string" === typeof returnFiber,
@@ -2608,26 +2770,31 @@ function ChildReconciler(shouldTrackSideEffects) {
       (newFiber.effectTag = 2);
     return newFiber;
   }
-  function updateTextNode(returnFiber, current, textContent, expirationTime) {
-    if (null === current || 6 !== current.tag)
+  function updateTextNode(
+    returnFiber,
+    current$$1,
+    textContent,
+    expirationTime
+  ) {
+    if (null === current$$1 || 6 !== current$$1.tag)
       return (
-        (current = createFiberFromText(
+        (current$$1 = createFiberFromText(
           textContent,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, textContent, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, textContent, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateElement(returnFiber, current, element, expirationTime) {
-    if (null !== current && current.type === element.type)
+  function updateElement(returnFiber, current$$1, element, expirationTime) {
+    if (null !== current$$1 && current$$1.type === element.type)
       return (
-        (expirationTime = useFiber(current, element.props, expirationTime)),
-        (expirationTime.ref = coerceRef(returnFiber, current, element)),
+        (expirationTime = useFiber(current$$1, element.props, expirationTime)),
+        (expirationTime.ref = coerceRef(returnFiber, current$$1, element)),
         (expirationTime.return = returnFiber),
         expirationTime
       );
@@ -2636,45 +2803,51 @@ function ChildReconciler(shouldTrackSideEffects) {
       returnFiber.mode,
       expirationTime
     );
-    expirationTime.ref = coerceRef(returnFiber, current, element);
+    expirationTime.ref = coerceRef(returnFiber, current$$1, element);
     expirationTime.return = returnFiber;
     return expirationTime;
   }
-  function updatePortal(returnFiber, current, portal, expirationTime) {
+  function updatePortal(returnFiber, current$$1, portal, expirationTime) {
     if (
-      null === current ||
-      4 !== current.tag ||
-      current.stateNode.containerInfo !== portal.containerInfo ||
-      current.stateNode.implementation !== portal.implementation
+      null === current$$1 ||
+      4 !== current$$1.tag ||
+      current$$1.stateNode.containerInfo !== portal.containerInfo ||
+      current$$1.stateNode.implementation !== portal.implementation
     )
       return (
-        (current = createFiberFromPortal(
+        (current$$1 = createFiberFromPortal(
           portal,
           returnFiber.mode,
           expirationTime
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, portal.children || [], expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
-  function updateFragment(returnFiber, current, fragment, expirationTime, key) {
-    if (null === current || 10 !== current.tag)
+  function updateFragment(
+    returnFiber,
+    current$$1,
+    fragment,
+    expirationTime,
+    key
+  ) {
+    if (null === current$$1 || 10 !== current$$1.tag)
       return (
-        (current = createFiberFromFragment(
+        (current$$1 = createFiberFromFragment(
           fragment,
           returnFiber.mode,
           expirationTime,
           key
         )),
-        (current.return = returnFiber),
-        current
+        (current$$1.return = returnFiber),
+        current$$1
       );
-    current = useFiber(current, fragment, expirationTime);
-    current.return = returnFiber;
-    return current;
+    current$$1 = useFiber(current$$1, fragment, expirationTime);
+    current$$1.return = returnFiber;
+    return current$$1;
   }
   function createChild(returnFiber, newChild, expirationTime) {
     if ("string" === typeof newChild || "number" === typeof newChild)
@@ -3240,22 +3413,15 @@ function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
         (hydrationParentFiber = fiber$jscomp$0);
   }
 }
-function reconcileChildren(current, workInProgress, nextChildren) {
-  reconcileChildrenAtExpirationTime(
-    current,
-    workInProgress,
-    nextChildren,
-    workInProgress.expirationTime
-  );
-}
-function reconcileChildrenAtExpirationTime(
-  current,
+var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
+function reconcileChildren(
+  current$$1,
   workInProgress,
   nextChildren,
   renderExpirationTime
 ) {
   workInProgress.child =
-    null === current
+    null === current$$1
       ? mountChildFibers(
           workInProgress,
           null,
@@ -3264,50 +3430,50 @@ function reconcileChildrenAtExpirationTime(
         )
       : reconcileChildFibers(
           workInProgress,
-          current.child,
+          current$$1.child,
           nextChildren,
           renderExpirationTime
         );
 }
-function markRef(current, workInProgress) {
+function markRef(current$$1, workInProgress) {
   var ref = workInProgress.ref;
   if (
-    (null === current && null !== ref) ||
-    (null !== current && current.ref !== ref)
+    (null === current$$1 && null !== ref) ||
+    (null !== current$$1 && current$$1.ref !== ref)
   )
     workInProgress.effectTag |= 128;
 }
 function finishClassComponent(
-  current,
+  current$$1,
   workInProgress,
   shouldUpdate,
   hasContext,
   renderExpirationTime
 ) {
-  markRef(current, workInProgress);
+  markRef(current$$1, workInProgress);
   var didCaptureError = 0 !== (workInProgress.effectTag & 64);
   if (!shouldUpdate && !didCaptureError)
     return (
       hasContext && invalidateContextProvider(workInProgress, !1),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
+      bailoutOnAlreadyFinishedWork(
+        current$$1,
+        workInProgress,
+        renderExpirationTime
+      )
     );
   shouldUpdate = workInProgress.stateNode;
-  ReactCurrentOwner.current = workInProgress;
+  ReactCurrentOwner$3.current = workInProgress;
   if (didCaptureError) {
     var nextChildren = null;
     baseStartTime = -1;
   } else nextChildren = shouldUpdate.render();
   workInProgress.effectTag |= 1;
-  didCaptureError &&
-    (reconcileChildrenAtExpirationTime(
-      current,
-      workInProgress,
-      null,
-      renderExpirationTime
-    ),
+  null !== current$$1 &&
+    didCaptureError &&
+    (reconcileChildren(current$$1, workInProgress, null, renderExpirationTime),
     (workInProgress.child = null));
-  reconcileChildrenAtExpirationTime(
-    current,
+  reconcileChildren(
+    current$$1,
     workInProgress,
     nextChildren,
     renderExpirationTime
@@ -3329,170 +3495,62 @@ function pushHostRootContext(workInProgress) {
       pushTopLevelContextObject(workInProgress, root.context, !1);
   pushHostContainer(workInProgress, root.containerInfo);
 }
-function propagateContextChange(
+function bailoutOnAlreadyFinishedWork(
+  current$$1,
   workInProgress,
-  context,
-  changedBits,
   renderExpirationTime
 ) {
-  var fiber = workInProgress.child;
-  null !== fiber && (fiber.return = workInProgress);
-  for (; null !== fiber; ) {
-    switch (fiber.tag) {
-      case 12:
-        var nextFiber = fiber.stateNode | 0;
-        if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
-          for (nextFiber = fiber; null !== nextFiber; ) {
-            var alternate = nextFiber.alternate;
-            if (
-              0 === nextFiber.expirationTime ||
-              nextFiber.expirationTime > renderExpirationTime
-            )
-              (nextFiber.expirationTime = renderExpirationTime),
-                null !== alternate &&
-                  (0 === alternate.expirationTime ||
-                    alternate.expirationTime > renderExpirationTime) &&
-                  (alternate.expirationTime = renderExpirationTime);
-            else if (
-              null !== alternate &&
-              (0 === alternate.expirationTime ||
-                alternate.expirationTime > renderExpirationTime)
-            )
-              alternate.expirationTime = renderExpirationTime;
-            else break;
-            nextFiber = nextFiber.return;
-          }
-          nextFiber = null;
-        } else nextFiber = fiber.child;
-        break;
-      case 13:
-        nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
-        break;
-      default:
-        nextFiber = fiber.child;
-    }
-    if (null !== nextFiber) nextFiber.return = fiber;
-    else
-      for (nextFiber = fiber; null !== nextFiber; ) {
-        if (nextFiber === workInProgress) {
-          nextFiber = null;
-          break;
-        }
-        fiber = nextFiber.sibling;
-        if (null !== fiber) {
-          fiber.return = nextFiber.return;
-          nextFiber = fiber;
-          break;
-        }
-        nextFiber = nextFiber.return;
-      }
-    fiber = nextFiber;
-  }
-}
-function updateContextProvider(current, workInProgress, renderExpirationTime) {
-  var context = workInProgress.type._context,
-    newProps = workInProgress.pendingProps,
-    oldProps = workInProgress.memoizedProps,
-    canBailOnProps = !0;
-  if (didPerformWorkStackCursor.current) canBailOnProps = !1;
-  else if (oldProps === newProps)
-    return (
-      (workInProgress.stateNode = 0),
-      pushProvider(workInProgress),
-      bailoutOnAlreadyFinishedWork(current, workInProgress)
-    );
-  var newValue = newProps.value;
-  workInProgress.memoizedProps = newProps;
-  if (null === oldProps) newValue = 1073741823;
-  else if (oldProps.value === newProps.value) {
-    if (oldProps.children === newProps.children && canBailOnProps)
-      return (
-        (workInProgress.stateNode = 0),
-        pushProvider(workInProgress),
-        bailoutOnAlreadyFinishedWork(current, workInProgress)
-      );
-    newValue = 0;
-  } else {
-    var oldValue = oldProps.value;
-    if (
-      (oldValue === newValue &&
-        (0 !== oldValue || 1 / oldValue === 1 / newValue)) ||
-      (oldValue !== oldValue && newValue !== newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-      newValue = 0;
-    } else if (
-      ((newValue =
-        "function" === typeof context._calculateChangedBits
-          ? context._calculateChangedBits(oldValue, newValue)
-          : 1073741823),
-      (newValue |= 0),
-      0 === newValue)
-    ) {
-      if (oldProps.children === newProps.children && canBailOnProps)
-        return (
-          (workInProgress.stateNode = 0),
-          pushProvider(workInProgress),
-          bailoutOnAlreadyFinishedWork(current, workInProgress)
-        );
-    } else
-      propagateContextChange(
-        workInProgress,
-        context,
-        newValue,
-        renderExpirationTime
-      );
-  }
-  workInProgress.stateNode = newValue;
-  pushProvider(workInProgress);
-  reconcileChildren(current, workInProgress, newProps.children);
-  return workInProgress.child;
-}
-function bailoutOnAlreadyFinishedWork(current, workInProgress) {
+  null !== current$$1 &&
+    (workInProgress.firstContextDependency = current$$1.firstContextDependency);
   baseStartTime = -1;
+  var childExpirationTime = workInProgress.childExpirationTime;
+  if (0 === childExpirationTime || childExpirationTime > renderExpirationTime)
+    return null;
   invariant(
-    null === current || workInProgress.child === current.child,
+    null === current$$1 || workInProgress.child === current$$1.child,
     "Resuming work not yet implemented."
   );
   if (null !== workInProgress.child) {
-    current = workInProgress.child;
-    var newChild = createWorkInProgress(
-      current,
-      current.pendingProps,
-      current.expirationTime
+    current$$1 = workInProgress.child;
+    renderExpirationTime = createWorkInProgress(
+      current$$1,
+      current$$1.pendingProps,
+      current$$1.expirationTime
     );
-    workInProgress.child = newChild;
-    for (newChild.return = workInProgress; null !== current.sibling; )
-      (current = current.sibling),
-        (newChild = newChild.sibling = createWorkInProgress(
-          current,
-          current.pendingProps,
-          current.expirationTime
+    workInProgress.child = renderExpirationTime;
+    for (
+      renderExpirationTime.return = workInProgress;
+      null !== current$$1.sibling;
+
+    )
+      (current$$1 = current$$1.sibling),
+        (renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(
+          current$$1,
+          current$$1.pendingProps,
+          current$$1.expirationTime
         )),
-        (newChild.return = workInProgress);
-    newChild.sibling = null;
+        (renderExpirationTime.return = workInProgress);
+    renderExpirationTime.sibling = null;
   }
   return workInProgress.child;
 }
-function beginWork(current, workInProgress, renderExpirationTime) {
+function beginWork(current$$1, workInProgress, renderExpirationTime) {
   workInProgress.mode & 4 &&
     ((workInProgress.actualDuration =
       now$1() - workInProgress.actualDuration - totalElapsedPauseTime),
     (workInProgress.actualStartTime = now$1()));
+  var updateExpirationTime = workInProgress.expirationTime;
   if (
-    0 === workInProgress.expirationTime ||
-    workInProgress.expirationTime > renderExpirationTime
+    !didPerformWorkStackCursor.current &&
+    (0 === updateExpirationTime || updateExpirationTime > renderExpirationTime)
   ) {
-    baseStartTime = -1;
     switch (workInProgress.tag) {
       case 3:
         pushHostRootContext(workInProgress);
         break;
+      case 5:
+        pushHostContext(workInProgress);
+        break;
       case 2:
         pushContextProvider(workInProgress);
         break;
@@ -3503,21 +3561,31 @@ function beginWork(current, workInProgress, renderExpirationTime) {
         );
         break;
       case 13:
+        workInProgress.stateNode = 0;
         pushProvider(workInProgress);
+        break;
+      case 15:
+        workInProgress.effectTag |= 4;
     }
-    return null;
+    return bailoutOnAlreadyFinishedWork(
+      current$$1,
+      workInProgress,
+      renderExpirationTime
+    );
   }
+  workInProgress.expirationTime = 0;
   switch (workInProgress.tag) {
     case 0:
       invariant(
-        null === current,
+        null === current$$1,
         "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue."
       );
-      var fn = workInProgress.type,
-        props = workInProgress.pendingProps,
-        unmaskedContext = getUnmaskedContext(workInProgress);
+      var fn = workInProgress.type;
+      updateExpirationTime = workInProgress.pendingProps;
+      var unmaskedContext = getUnmaskedContext(workInProgress);
       unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
-      fn = fn(props, unmaskedContext);
+      prepareToReadContext(workInProgress, renderExpirationTime);
+      fn = fn(updateExpirationTime, unmaskedContext);
       workInProgress.effectTag |= 1;
       "object" === typeof fn &&
       null !== fn &&
@@ -3529,45 +3597,52 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null !== fn.state && void 0 !== fn.state ? fn.state : null),
           (unmaskedContext = unmaskedContext.getDerivedStateFromProps),
           "function" === typeof unmaskedContext &&
-            applyDerivedStateFromProps(workInProgress, unmaskedContext, props),
-          (props = pushContextProvider(workInProgress)),
+            applyDerivedStateFromProps(
+              workInProgress,
+              unmaskedContext,
+              updateExpirationTime
+            ),
+          (updateExpirationTime = pushContextProvider(workInProgress)),
           (fn.updater = classComponentUpdater),
           (workInProgress.stateNode = fn),
           (fn._reactInternalFiber = workInProgress),
           mountClassInstance(workInProgress, renderExpirationTime),
-          (current = finishClassComponent(
-            current,
+          (current$$1 = finishClassComponent(
+            current$$1,
             workInProgress,
             !0,
-            props,
+            updateExpirationTime,
             renderExpirationTime
           )))
         : ((workInProgress.tag = 1),
-          reconcileChildren(current, workInProgress, fn),
-          (workInProgress.memoizedProps = props),
-          (current = workInProgress.child));
-      return current;
+          reconcileChildren(
+            current$$1,
+            workInProgress,
+            fn,
+            renderExpirationTime
+          ),
+          (workInProgress.memoizedProps = updateExpirationTime),
+          (current$$1 = workInProgress.child));
+      return current$$1;
     case 1:
       return (
-        (props = workInProgress.type),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? ((fn = getUnmaskedContext(workInProgress)),
-            (fn = getMaskedContext(workInProgress, fn)),
-            (props = props(renderExpirationTime, fn)),
-            (workInProgress.effectTag |= 1),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (fn = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = getUnmaskedContext(workInProgress)),
+        (unmaskedContext = getMaskedContext(workInProgress, unmaskedContext)),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (fn = fn(updateExpirationTime, unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 2:
-      props = pushContextProvider(workInProgress);
-      if (null === current)
+      updateExpirationTime = pushContextProvider(workInProgress);
+      fn = prepareToReadContext(workInProgress, renderExpirationTime);
+      if (null === current$$1)
         if (null === workInProgress.stateNode) {
-          var props$jscomp$0 = workInProgress.pendingProps,
+          var props = workInProgress.pendingProps,
             ctor = workInProgress.type;
           fn = getUnmaskedContext(workInProgress);
           var needsContext =
@@ -3575,15 +3650,13 @@ function beginWork(current, workInProgress, renderExpirationTime) {
             null != workInProgress.type.contextTypes;
           unmaskedContext = needsContext
             ? getMaskedContext(workInProgress, fn)
-            : emptyObject;
-          props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
+            : emptyContextObject;
+          props = new ctor(props, unmaskedContext);
           workInProgress.memoizedState =
-            null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state
-              ? props$jscomp$0.state
-              : null;
-          props$jscomp$0.updater = classComponentUpdater;
-          workInProgress.stateNode = props$jscomp$0;
-          props$jscomp$0._reactInternalFiber = workInProgress;
+            null !== props.state && void 0 !== props.state ? props.state : null;
+          props.updater = classComponentUpdater;
+          workInProgress.stateNode = props;
+          props._reactInternalFiber = workInProgress;
           needsContext &&
             ((needsContext = workInProgress.stateNode),
             (needsContext.__reactInternalMemoizedUnmaskedChildContext = fn),
@@ -3591,122 +3664,46 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           mountClassInstance(workInProgress, renderExpirationTime);
           fn = !0;
         } else {
-          ctor = workInProgress.type;
-          fn = workInProgress.stateNode;
-          needsContext = workInProgress.memoizedProps;
-          unmaskedContext = workInProgress.pendingProps;
-          fn.props = needsContext;
-          var oldContext = fn.context;
-          props$jscomp$0 = getUnmaskedContext(workInProgress);
-          props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
-          var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
-          (ctor =
+          var ctor$jscomp$0 = workInProgress.type;
+          unmaskedContext = workInProgress.stateNode;
+          props = workInProgress.memoizedProps;
+          needsContext = workInProgress.pendingProps;
+          unmaskedContext.props = props;
+          var oldContext = unmaskedContext.context;
+          ctor = getUnmaskedContext(workInProgress);
+          ctor = getMaskedContext(workInProgress, ctor);
+          var getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps;
+          (ctor$jscomp$0 =
             "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((needsContext !== unmaskedContext ||
-              oldContext !== props$jscomp$0) &&
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((props !== needsContext || oldContext !== ctor) &&
               callComponentWillReceiveProps(
                 workInProgress,
-                fn,
                 unmaskedContext,
-                props$jscomp$0
+                needsContext,
+                ctor
               ));
           hasForceUpdate = !1;
           var oldState = workInProgress.memoizedState;
-          oldContext = fn.state = oldState;
+          oldContext = unmaskedContext.state = oldState;
           var updateQueue = workInProgress.updateQueue;
           null !== updateQueue &&
             (processUpdateQueue(
               workInProgress,
               updateQueue,
+              needsContext,
               unmaskedContext,
-              fn,
               renderExpirationTime
             ),
             (oldContext = workInProgress.memoizedState));
-          needsContext !== unmaskedContext ||
+          props !== needsContext ||
           oldState !== oldContext ||
           didPerformWorkStackCursor.current ||
-          hasForceUpdate
-            ? ("function" === typeof getDerivedStateFromProps &&
-                (applyDerivedStateFromProps(
-                  workInProgress,
-                  getDerivedStateFromProps,
-                  unmaskedContext
-                ),
-                (oldContext = workInProgress.memoizedState)),
-              (needsContext =
-                hasForceUpdate ||
-                checkShouldComponentUpdate(
-                  workInProgress,
-                  needsContext,
-                  unmaskedContext,
-                  oldState,
-                  oldContext,
-                  props$jscomp$0
-                ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillMount &&
-                      "function" !== typeof fn.componentWillMount) ||
-                    ("function" === typeof fn.componentWillMount &&
-                      fn.componentWillMount(),
-                    "function" === typeof fn.UNSAFE_componentWillMount &&
-                      fn.UNSAFE_componentWillMount()),
-                  "function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4))
-                : ("function" === typeof fn.componentDidMount &&
-                    (workInProgress.effectTag |= 4),
-                  (workInProgress.memoizedProps = unmaskedContext),
-                  (workInProgress.memoizedState = oldContext)),
-              (fn.props = unmaskedContext),
-              (fn.state = oldContext),
-              (fn.context = props$jscomp$0),
-              (fn = needsContext))
-            : ("function" === typeof fn.componentDidMount &&
-                (workInProgress.effectTag |= 4),
-              (fn = !1));
-        }
-      else
-        (ctor = workInProgress.type),
-          (fn = workInProgress.stateNode),
-          (unmaskedContext = workInProgress.memoizedProps),
-          (needsContext = workInProgress.pendingProps),
-          (fn.props = unmaskedContext),
-          (oldContext = fn.context),
-          (props$jscomp$0 = getUnmaskedContext(workInProgress)),
-          (props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0)),
-          (getDerivedStateFromProps = ctor.getDerivedStateFromProps),
-          (ctor =
-            "function" === typeof getDerivedStateFromProps ||
-            "function" === typeof fn.getSnapshotBeforeUpdate) ||
-            ("function" !== typeof fn.UNSAFE_componentWillReceiveProps &&
-              "function" !== typeof fn.componentWillReceiveProps) ||
-            ((unmaskedContext !== needsContext ||
-              oldContext !== props$jscomp$0) &&
-              callComponentWillReceiveProps(
-                workInProgress,
-                fn,
-                needsContext,
-                props$jscomp$0
-              )),
-          (hasForceUpdate = !1),
-          (oldContext = workInProgress.memoizedState),
-          (oldState = fn.state = oldContext),
-          (updateQueue = workInProgress.updateQueue),
-          null !== updateQueue &&
-            (processUpdateQueue(
-              workInProgress,
-              updateQueue,
-              needsContext,
-              fn,
-              renderExpirationTime
-            ),
-            (oldState = workInProgress.memoizedState)),
-          unmaskedContext !== needsContext ||
-          oldContext !== oldState ||
-          didPerformWorkStackCursor.current ||
+          fn ||
           hasForceUpdate
             ? ("function" === typeof getDerivedStateFromProps &&
                 (applyDerivedStateFromProps(
@@ -3714,128 +3711,203 @@ function beginWork(current, workInProgress, renderExpirationTime) {
                   getDerivedStateFromProps,
                   needsContext
                 ),
-                (oldState = workInProgress.memoizedState)),
-              (getDerivedStateFromProps =
+                (oldContext = workInProgress.memoizedState)),
+              (fn =
                 hasForceUpdate ||
+                fn ||
                 checkShouldComponentUpdate(
                   workInProgress,
-                  unmaskedContext,
+                  props,
                   needsContext,
+                  oldState,
+                  oldContext,
+                  ctor
+                ))
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillMount) ||
+                    ("function" === typeof unmaskedContext.componentWillMount &&
+                      unmaskedContext.componentWillMount(),
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillMount &&
+                      unmaskedContext.UNSAFE_componentWillMount()),
+                  "function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4))
+                : ("function" === typeof unmaskedContext.componentDidMount &&
+                    (workInProgress.effectTag |= 4),
+                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedState = oldContext)),
+              (unmaskedContext.props = needsContext),
+              (unmaskedContext.state = oldContext),
+              (unmaskedContext.context = ctor))
+            : ("function" === typeof unmaskedContext.componentDidMount &&
+                (workInProgress.effectTag |= 4),
+              (fn = !1));
+        }
+      else
+        (ctor$jscomp$0 = workInProgress.type),
+          (unmaskedContext = workInProgress.stateNode),
+          (needsContext = workInProgress.memoizedProps),
+          (props = workInProgress.pendingProps),
+          (unmaskedContext.props = needsContext),
+          (oldContext = unmaskedContext.context),
+          (ctor = getUnmaskedContext(workInProgress)),
+          (ctor = getMaskedContext(workInProgress, ctor)),
+          (getDerivedStateFromProps = ctor$jscomp$0.getDerivedStateFromProps),
+          (ctor$jscomp$0 =
+            "function" === typeof getDerivedStateFromProps ||
+            "function" === typeof unmaskedContext.getSnapshotBeforeUpdate) ||
+            ("function" !==
+              typeof unmaskedContext.UNSAFE_componentWillReceiveProps &&
+              "function" !==
+                typeof unmaskedContext.componentWillReceiveProps) ||
+            ((needsContext !== props || oldContext !== ctor) &&
+              callComponentWillReceiveProps(
+                workInProgress,
+                unmaskedContext,
+                props,
+                ctor
+              )),
+          (hasForceUpdate = !1),
+          (oldContext = workInProgress.memoizedState),
+          (oldState = unmaskedContext.state = oldContext),
+          (updateQueue = workInProgress.updateQueue),
+          null !== updateQueue &&
+            (processUpdateQueue(
+              workInProgress,
+              updateQueue,
+              props,
+              unmaskedContext,
+              renderExpirationTime
+            ),
+            (oldState = workInProgress.memoizedState)),
+          needsContext !== props ||
+          oldContext !== oldState ||
+          didPerformWorkStackCursor.current ||
+          fn ||
+          hasForceUpdate
+            ? ("function" === typeof getDerivedStateFromProps &&
+                (applyDerivedStateFromProps(
+                  workInProgress,
+                  getDerivedStateFromProps,
+                  props
+                ),
+                (oldState = workInProgress.memoizedState)),
+              (fn =
+                hasForceUpdate ||
+                fn ||
+                checkShouldComponentUpdate(
+                  workInProgress,
+                  needsContext,
+                  props,
                   oldContext,
                   oldState,
-                  props$jscomp$0
+                  ctor
                 ))
-                ? (ctor ||
-                    ("function" !== typeof fn.UNSAFE_componentWillUpdate &&
-                      "function" !== typeof fn.componentWillUpdate) ||
-                    ("function" === typeof fn.componentWillUpdate &&
-                      fn.componentWillUpdate(
-                        needsContext,
+                ? (ctor$jscomp$0 ||
+                    ("function" !==
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      "function" !==
+                        typeof unmaskedContext.componentWillUpdate) ||
+                    ("function" ===
+                      typeof unmaskedContext.componentWillUpdate &&
+                      unmaskedContext.componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       ),
-                    "function" === typeof fn.UNSAFE_componentWillUpdate &&
-                      fn.UNSAFE_componentWillUpdate(
-                        needsContext,
+                    "function" ===
+                      typeof unmaskedContext.UNSAFE_componentWillUpdate &&
+                      unmaskedContext.UNSAFE_componentWillUpdate(
+                        props,
                         oldState,
-                        props$jscomp$0
+                        ctor
                       )),
-                  "function" === typeof fn.componentDidUpdate &&
+                  "function" === typeof unmaskedContext.componentDidUpdate &&
                     (workInProgress.effectTag |= 4),
-                  "function" === typeof fn.getSnapshotBeforeUpdate &&
+                  "function" ===
+                    typeof unmaskedContext.getSnapshotBeforeUpdate &&
                     (workInProgress.effectTag |= 256))
-                : ("function" !== typeof fn.componentDidUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 4),
-                  "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                    (unmaskedContext === current.memoizedProps &&
-                      oldContext === current.memoizedState) ||
+                  "function" !==
+                    typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                    (needsContext === current$$1.memoizedProps &&
+                      oldContext === current$$1.memoizedState) ||
                     (workInProgress.effectTag |= 256),
-                  (workInProgress.memoizedProps = needsContext),
+                  (workInProgress.memoizedProps = props),
                   (workInProgress.memoizedState = oldState)),
-              (fn.props = needsContext),
-              (fn.state = oldState),
-              (fn.context = props$jscomp$0),
-              (fn = getDerivedStateFromProps))
-            : ("function" !== typeof fn.componentDidUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              (unmaskedContext.props = props),
+              (unmaskedContext.state = oldState),
+              (unmaskedContext.context = ctor))
+            : ("function" !== typeof unmaskedContext.componentDidUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 4),
-              "function" !== typeof fn.getSnapshotBeforeUpdate ||
-                (unmaskedContext === current.memoizedProps &&
-                  oldContext === current.memoizedState) ||
+              "function" !== typeof unmaskedContext.getSnapshotBeforeUpdate ||
+                (needsContext === current$$1.memoizedProps &&
+                  oldContext === current$$1.memoizedState) ||
                 (workInProgress.effectTag |= 256),
               (fn = !1));
       return finishClassComponent(
-        current,
+        current$$1,
         workInProgress,
         fn,
-        props,
+        updateExpirationTime,
         renderExpirationTime
       );
     case 3:
       return (
         pushHostRootContext(workInProgress),
-        (props = workInProgress.updateQueue),
-        null !== props
-          ? ((fn = workInProgress.memoizedState),
-            (fn = null !== fn ? fn.element : null),
-            processUpdateQueue(
+        (updateExpirationTime = workInProgress.updateQueue),
+        invariant(
+          null !== updateExpirationTime,
+          "If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."
+        ),
+        (fn = workInProgress.memoizedState),
+        (fn = null !== fn ? fn.element : null),
+        processUpdateQueue(
+          workInProgress,
+          updateExpirationTime,
+          workInProgress.pendingProps,
+          null,
+          renderExpirationTime
+        ),
+        (updateExpirationTime = workInProgress.memoizedState.element),
+        updateExpirationTime === fn
+          ? (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
               workInProgress,
-              props,
-              workInProgress.pendingProps,
-              null,
+              renderExpirationTime
+            ))
+          : (reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
               renderExpirationTime
             ),
-            (renderExpirationTime = workInProgress.memoizedState.element),
-            renderExpirationTime === fn
-              ? (current = bailoutOnAlreadyFinishedWork(
-                  current,
-                  workInProgress
-                ))
-              : (reconcileChildren(
-                  current,
-                  workInProgress,
-                  renderExpirationTime
-                ),
-                (current = workInProgress.child)))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+            (current$$1 = workInProgress.child)),
+        current$$1
       );
     case 5:
       return (
-        requiredContext(rootInstanceStackCursor.current),
-        (renderExpirationTime = requiredContext(contextStackCursor$1.current)),
-        (props = workInProgress.type),
-        (props =
-          "AndroidTextInput" === props ||
-          "RCTMultilineTextInputView" === props ||
-          "RCTSinglelineTextInputView" === props ||
-          "RCTText" === props ||
-          "RCTVirtualText" === props),
-        (props =
-          renderExpirationTime.isInAParentText !== props
-            ? { isInAParentText: props }
-            : renderExpirationTime),
-        renderExpirationTime !== props &&
-          (push(contextFiberStackCursor, workInProgress, workInProgress),
-          push(contextStackCursor$1, props, workInProgress)),
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
-        (props = workInProgress.memoizedProps),
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current || props !== renderExpirationTime
-          ? ((props = renderExpirationTime.children),
-            markRef(current, workInProgress),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        pushHostContext(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        markRef(current$$1, workInProgress),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        (current$$1 = workInProgress.child),
+        current$$1
       );
     case 6:
       return (
-        null === current && tryToClaimNextHydratableInstance(workInProgress),
+        null === current$$1 && tryToClaimNextHydratableInstance(workInProgress),
         (workInProgress.memoizedProps = workInProgress.pendingProps),
         null
       );
@@ -3847,114 +3919,182 @@ function beginWork(current, workInProgress, renderExpirationTime) {
           workInProgress,
           workInProgress.stateNode.containerInfo
         ),
-        (props = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== props
-          ? (null === current
-              ? (workInProgress.child = reconcileChildFibers(
-                  workInProgress,
-                  null,
-                  props,
-                  renderExpirationTime
-                ))
-              : reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = props),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        null === current$$1
+          ? (workInProgress.child = reconcileChildFibers(
+              workInProgress,
+              null,
+              updateExpirationTime,
+              renderExpirationTime
+            ))
+          : reconcileChildren(
+              current$$1,
+              workInProgress,
+              updateExpirationTime,
+              renderExpirationTime
+            ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 14:
       return (
-        (props = workInProgress.type.render),
-        (renderExpirationTime = workInProgress.pendingProps),
-        (fn = workInProgress.ref),
+        (fn = workInProgress.type.render),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (unmaskedContext = workInProgress.ref),
         didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime ||
-        fn !== (null !== current ? current.ref : null)
-          ? ((props = props(renderExpirationTime, fn)),
-            reconcileChildren(current, workInProgress, props),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        workInProgress.memoizedProps !== updateExpirationTime ||
+        unmaskedContext !== (null !== current$$1 ? current$$1.ref : null)
+          ? ((fn = fn(updateExpirationTime, unmaskedContext)),
+            reconcileChildren(
+              current$$1,
+              workInProgress,
+              fn,
+              renderExpirationTime
+            ),
+            (workInProgress.memoizedProps = updateExpirationTime),
+            (current$$1 = workInProgress.child))
+          : (current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            )),
+        current$$1
       );
     case 10:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
-        didPerformWorkStackCursor.current ||
-        workInProgress.memoizedProps !== renderExpirationTime
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 11:
       return (
-        (renderExpirationTime = workInProgress.pendingProps.children),
-        didPerformWorkStackCursor.current ||
-        (null !== renderExpirationTime &&
-          workInProgress.memoizedProps !== renderExpirationTime)
-          ? (reconcileChildren(current, workInProgress, renderExpirationTime),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child))
-          : (current = bailoutOnAlreadyFinishedWork(current, workInProgress)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps.children),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 15:
       return (
-        (renderExpirationTime = workInProgress.pendingProps),
         (workInProgress.effectTag |= 4),
-        workInProgress.memoizedProps === renderExpirationTime
-          ? (current = bailoutOnAlreadyFinishedWork(current, workInProgress))
-          : (reconcileChildren(
-              current,
-              workInProgress,
-              renderExpirationTime.children
-            ),
-            (workInProgress.memoizedProps = renderExpirationTime),
-            (current = workInProgress.child)),
-        current
+        (updateExpirationTime = workInProgress.pendingProps),
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          updateExpirationTime.children,
+          renderExpirationTime
+        ),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
       );
     case 13:
-      return updateContextProvider(
-        current,
-        workInProgress,
-        renderExpirationTime
-      );
-    case 12:
-      a: if (
-        ((fn = workInProgress.type),
-        (unmaskedContext = workInProgress.pendingProps),
-        (needsContext = workInProgress.memoizedProps),
-        (props = fn._currentValue),
-        (props$jscomp$0 = fn._changedBits),
-        didPerformWorkStackCursor.current ||
-          0 !== props$jscomp$0 ||
-          needsContext !== unmaskedContext)
-      ) {
-        workInProgress.memoizedProps = unmaskedContext;
-        ctor = unmaskedContext.unstable_observedBits;
-        if (void 0 === ctor || null === ctor) ctor = 1073741823;
-        workInProgress.stateNode = ctor;
-        if (0 !== (props$jscomp$0 & ctor))
+      a: {
+        updateExpirationTime = workInProgress.type._context;
+        fn = workInProgress.pendingProps;
+        unmaskedContext = workInProgress.memoizedProps;
+        needsContext = fn.value;
+        workInProgress.memoizedProps = fn;
+        if (null === unmaskedContext) needsContext = 1073741823;
+        else if (unmaskedContext.value === fn.value) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((props = unmaskedContext.value),
+          (props === needsContext &&
+            (0 !== props || 1 / props === 1 / needsContext)) ||
+            (props !== props && needsContext !== needsContext))
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+          needsContext = 0;
+        } else if (
+          ((needsContext =
+            "function" === typeof updateExpirationTime._calculateChangedBits
+              ? updateExpirationTime._calculateChangedBits(props, needsContext)
+              : 1073741823),
+          (needsContext |= 0),
+          0 === needsContext)
+        ) {
+          if (
+            unmaskedContext.children === fn.children &&
+            !didPerformWorkStackCursor.current
+          ) {
+            workInProgress.stateNode = 0;
+            pushProvider(workInProgress);
+            current$$1 = bailoutOnAlreadyFinishedWork(
+              current$$1,
+              workInProgress,
+              renderExpirationTime
+            );
+            break a;
+          }
+        } else
           propagateContextChange(
             workInProgress,
-            fn,
-            props$jscomp$0,
+            updateExpirationTime,
+            needsContext,
             renderExpirationTime
           );
-        else if (needsContext === unmaskedContext) {
-          current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-          break a;
-        }
-        renderExpirationTime = unmaskedContext.children;
-        renderExpirationTime = renderExpirationTime(props);
-        workInProgress.effectTag |= 1;
-        reconcileChildren(current, workInProgress, renderExpirationTime);
-        current = workInProgress.child;
-      } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);
-      return current;
+        workInProgress.stateNode = needsContext;
+        pushProvider(workInProgress);
+        reconcileChildren(
+          current$$1,
+          workInProgress,
+          fn.children,
+          renderExpirationTime
+        );
+        current$$1 = workInProgress.child;
+      }
+      return current$$1;
+    case 12:
+      return (
+        (unmaskedContext = workInProgress.type),
+        (updateExpirationTime = workInProgress.pendingProps),
+        (fn = updateExpirationTime.children),
+        prepareToReadContext(workInProgress, renderExpirationTime),
+        (unmaskedContext = readContext(
+          unmaskedContext,
+          updateExpirationTime.unstable_observedBits
+        )),
+        (fn = fn(unmaskedContext)),
+        (workInProgress.effectTag |= 1),
+        reconcileChildren(current$$1, workInProgress, fn, renderExpirationTime),
+        (workInProgress.memoizedProps = updateExpirationTime),
+        workInProgress.child
+      );
     default:
       invariant(
         !1,
@@ -3973,182 +4113,16 @@ updateHostComponent$1 = function(current, workInProgress, updatePayload) {
 updateHostText$1 = function(current, workInProgress, oldText, newText) {
   oldText !== newText && (workInProgress.effectTag |= 4);
 };
-function completeWork(current, workInProgress) {
-  var newProps = workInProgress.pendingProps;
-  workInProgress.mode & 4 && recordElapsedActualRenderTime(workInProgress);
-  switch (workInProgress.tag) {
-    case 1:
-      return null;
-    case 2:
-      return popContextProvider(workInProgress), null;
-    case 3:
-      popHostContainer(workInProgress);
-      popTopLevelContextObject(workInProgress);
-      newProps = workInProgress.stateNode;
-      newProps.pendingContext &&
-        ((newProps.context = newProps.pendingContext),
-        (newProps.pendingContext = null));
-      if (null === current || null === current.child)
-        workInProgress.effectTag &= -3;
-      updateHostContainer(workInProgress);
-      return null;
-    case 5:
-      popHostContext(workInProgress);
-      var rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        ),
-        type = workInProgress.type;
-      if (null !== current && null != workInProgress.stateNode) {
-        var oldProps = current.memoizedProps,
-          currentHostContext = requiredContext(contextStackCursor$1.current);
-        updateHostComponent$1(
-          current,
-          workInProgress,
-          emptyObject,
-          type,
-          oldProps,
-          newProps,
-          rootContainerInstance,
-          currentHostContext
-        );
-        current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      } 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
-          );
-        current = requiredContext(contextStackCursor$1.current);
-        oldProps = allocateTag();
-        currentHostContext = ReactNativeViewConfigRegistry.get(type);
-        invariant(
-          "RCTView" !== type || !current.isInAParentText,
-          "Nesting of <View> within <Text> is not currently supported."
-        );
-        var updatePayload = diffProperties(
-          null,
-          emptyObject$1,
-          newProps,
-          currentHostContext.validAttributes
-        );
-        UIManager.createView(
-          oldProps,
-          currentHostContext.uiViewClassName,
-          rootContainerInstance,
-          updatePayload
-        );
-        currentHostContext = new ReactNativeFiberHostComponent(
-          oldProps,
-          currentHostContext
-        );
-        instanceCache[oldProps] = workInProgress;
-        instanceProps[oldProps] = newProps;
-        a: for (oldProps = workInProgress.child; null !== oldProps; ) {
-          if (5 === oldProps.tag || 6 === oldProps.tag)
-            currentHostContext._children.push(oldProps.stateNode);
-          else if (4 !== oldProps.tag && null !== oldProps.child) {
-            oldProps.child.return = oldProps;
-            oldProps = oldProps.child;
-            continue;
-          }
-          if (oldProps === workInProgress) break;
-          for (; null === oldProps.sibling; ) {
-            if (null === oldProps.return || oldProps.return === workInProgress)
-              break a;
-            oldProps = oldProps.return;
-          }
-          oldProps.sibling.return = oldProps.return;
-          oldProps = oldProps.sibling;
-        }
-        finalizeInitialChildren(
-          currentHostContext,
-          type,
-          newProps,
-          rootContainerInstance,
-          current
-        ) && (workInProgress.effectTag |= 4);
-        workInProgress.stateNode = currentHostContext;
-        null !== workInProgress.ref && (workInProgress.effectTag |= 128);
-      }
-      return null;
-    case 6:
-      if (current && null != workInProgress.stateNode)
-        updateHostText$1(
-          current,
-          workInProgress,
-          current.memoizedProps,
-          newProps
-        );
-      else {
-        if ("string" !== typeof 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
-          );
-        rootContainerInstance = requiredContext(
-          rootInstanceStackCursor.current
-        );
-        type = requiredContext(contextStackCursor$1.current);
-        invariant(
-          type.isInAParentText,
-          "Text strings must be rendered within a <Text> component."
-        );
-        type = allocateTag();
-        UIManager.createView(type, "RCTRawText", rootContainerInstance, {
-          text: newProps
-        });
-        instanceCache[type] = workInProgress;
-        workInProgress.stateNode = type;
-      }
-      return null;
-    case 14:
-      return null;
-    case 16:
-      return null;
-    case 10:
-      return null;
-    case 11:
-      return null;
-    case 15:
-      return null;
-    case 4:
-      return (
-        popHostContainer(workInProgress),
-        updateHostContainer(workInProgress),
-        null
-      );
-    case 13:
-      return popProvider(workInProgress), null;
-    case 12:
-      return null;
-    case 0:
-      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."
-      );
-  }
-}
 function logError(boundary, errorInfo) {
   var source = errorInfo.source,
     stack = errorInfo.stack;
   null === stack &&
     null !== source &&
-    (stack = getStackAddendumByWorkInProgressFiber(source));
-  null !== source && getComponentName(source);
+    (stack = getStackByFiberInDevAndProd(source));
+  null !== source && getComponentName(source.type);
   source = null !== stack ? stack : "";
   errorInfo = errorInfo.value;
-  null !== boundary && 2 === boundary.tag && getComponentName(boundary);
+  null !== boundary && 2 === boundary.tag && getComponentName(boundary.type);
   try {
     if (errorInfo instanceof Error) {
       var message = errorInfo.message,
@@ -4170,37 +4144,38 @@ function logError(boundary, errorInfo) {
     (e && e.suppressReactErrorLogging) || console.error(e);
   }
 }
-function safelyDetachRef(current) {
-  var ref = current.ref;
+function safelyDetachRef(current$$1) {
+  var ref = current$$1.ref;
   if (null !== ref)
     if ("function" === typeof ref)
       try {
         ref(null);
       } catch (refError) {
-        captureCommitPhaseError(current, refError);
+        captureCommitPhaseError(current$$1, refError);
       }
     else ref.current = null;
 }
-function commitUnmount(current) {
-  "function" === typeof onCommitUnmount && onCommitUnmount(current);
-  switch (current.tag) {
+function commitUnmount(current$$1) {
+  "function" === typeof onCommitFiberUnmount &&
+    onCommitFiberUnmount(current$$1);
+  switch (current$$1.tag) {
     case 2:
-      safelyDetachRef(current);
-      var instance = current.stateNode;
+      safelyDetachRef(current$$1);
+      var instance = current$$1.stateNode;
       if ("function" === typeof instance.componentWillUnmount)
         try {
-          (instance.props = current.memoizedProps),
-            (instance.state = current.memoizedState),
+          (instance.props = current$$1.memoizedProps),
+            (instance.state = current$$1.memoizedState),
             instance.componentWillUnmount();
         } catch (unmountError) {
-          captureCommitPhaseError(current, unmountError);
+          captureCommitPhaseError(current$$1, unmountError);
         }
       break;
     case 5:
-      safelyDetachRef(current);
+      safelyDetachRef(current$$1);
       break;
     case 4:
-      unmountHostComponents(current);
+      unmountHostComponents(current$$1);
   }
 }
 function isHostParent(fiber) {
@@ -4351,9 +4326,9 @@ function commitPlacement(finishedWork) {
     node = node.sibling;
   }
 }
-function unmountHostComponents(current) {
+function unmountHostComponents(current$$1) {
   for (
-    var node = current,
+    var node = current$$1,
       currentParentIsValid = !1,
       currentParent = void 0,
       currentParentIsContainer = void 0;
@@ -4418,7 +4393,8 @@ function unmountHostComponents(current) {
       }
     } else if (
       (4 === node.tag
-        ? (currentParent = node.stateNode.containerInfo)
+        ? ((currentParent = node.stateNode.containerInfo),
+          (currentParentIsContainer = !0))
         : commitUnmount(node),
       null !== node.child)
     ) {
@@ -4426,9 +4402,9 @@ function unmountHostComponents(current) {
       node = node.child;
       continue;
     }
-    if (node === current) break;
+    if (node === current$$1) break;
     for (; null === node.sibling; ) {
-      if (null === node.return || node.return === current) return;
+      if (null === node.return || node.return === current$$1) return;
       node = node.return;
       4 === node.tag && (currentParentIsValid = !1);
     }
@@ -4436,7 +4412,7 @@ function unmountHostComponents(current) {
     node = node.sibling;
   }
 }
-function commitWork(current, finishedWork) {
+function commitWork(current$$1, finishedWork) {
   switch (finishedWork.tag) {
     case 2:
       break;
@@ -4444,7 +4420,7 @@ function commitWork(current, finishedWork) {
       var instance = finishedWork.stateNode;
       if (null != instance) {
         var newProps = finishedWork.memoizedProps;
-        current = null !== current ? current.memoizedProps : newProps;
+        current$$1 = null !== current$$1 ? current$$1.memoizedProps : newProps;
         var updatePayload = finishedWork.updateQueue;
         finishedWork.updateQueue = null;
         null !== updatePayload &&
@@ -4452,7 +4428,7 @@ function commitWork(current, finishedWork) {
           (instanceProps[instance._nativeTag] = newProps),
           (newProps = diffProperties(
             null,
-            current,
+            current$$1,
             newProps,
             finishedWork.validAttributes
           )),
@@ -4479,9 +4455,9 @@ function commitWork(current, finishedWork) {
       instance = finishedWork.memoizedProps.onRender;
       instance(
         finishedWork.memoizedProps.id,
-        null === current ? "mount" : "update",
+        null === current$$1 ? "mount" : "update",
         finishedWork.actualDuration,
-        finishedWork.treeBaseTime,
+        finishedWork.treeBaseDuration,
         finishedWork.actualStartTime,
         commitTime
       );
@@ -4540,10 +4516,12 @@ function unwindWork(workInProgress) {
         popHostContainer(workInProgress),
         popTopLevelContextObject(workInProgress),
         (effectTag = workInProgress.effectTag),
-        effectTag & 1024
-          ? ((workInProgress.effectTag = (effectTag & -1025) | 64),
-            workInProgress)
-          : null
+        invariant(
+          0 === (effectTag & 64),
+          "The root failed to unmount after an error. This is likely a bug in React. Please file an issue."
+        ),
+        (workInProgress.effectTag = (effectTag & -1025) | 64),
+        workInProgress
       );
     case 5:
       return popHostContext(workInProgress), null;
@@ -4563,16 +4541,14 @@ function unwindWork(workInProgress) {
       return null;
   }
 }
-var originalStartTimeMs = now$1(),
-  mostRecentCurrentTime = 2,
-  mostRecentCurrentTimeMs = originalStartTimeMs,
+var Dispatcher = { readContext: readContext },
+  ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
   lastUniqueAsyncExpiration = 0,
   expirationContext = 0,
   isWorking = !1,
   nextUnitOfWork = null,
   nextRoot = null,
   nextRenderExpirationTime = 0,
-  nextLatestTimeoutMs = -1,
   nextRenderDidError = !1,
   nextEffect = null,
   isCommitting$1 = !1,
@@ -4584,10 +4560,10 @@ function resetStack() {
       null !== interruptedWork;
 
     ) {
+      interruptedWork.mode & 4 && resumeActualRenderTimerIfPaused(!1);
       var interruptedWork$jscomp$0 = interruptedWork;
       interruptedWork$jscomp$0.mode & 4 &&
-        (resumeActualRenderTimerIfPaused(),
-        recordElapsedActualRenderTime(interruptedWork$jscomp$0));
+        recordElapsedActualRenderTime(interruptedWork$jscomp$0);
       switch (interruptedWork$jscomp$0.tag) {
         case 2:
           popContextProvider(interruptedWork$jscomp$0);
@@ -4609,129 +4585,315 @@ function resetStack() {
     }
   nextRoot = null;
   nextRenderExpirationTime = 0;
-  nextLatestTimeoutMs = -1;
   nextRenderDidError = !1;
   nextUnitOfWork = null;
 }
-function completeUnitOfWork(workInProgress$jscomp$0) {
+function completeUnitOfWork(workInProgress) {
   for (;;) {
-    var current = workInProgress$jscomp$0.alternate,
-      returnFiber = workInProgress$jscomp$0.return,
-      siblingFiber = workInProgress$jscomp$0.sibling;
-    if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
-      current = completeWork(
-        current,
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      var workInProgress = workInProgress$jscomp$0;
+    var current$$1 = workInProgress.alternate,
+      returnFiber = workInProgress.return,
+      siblingFiber = workInProgress.sibling;
+    if (0 === (workInProgress.effectTag & 512)) {
+      var current = current$$1;
+      current$$1 = workInProgress;
+      var newProps = current$$1.pendingProps;
+      switch (current$$1.tag) {
+        case 1:
+          break;
+        case 2:
+          popContextProvider(current$$1);
+          break;
+        case 3:
+          popHostContainer(current$$1);
+          popTopLevelContextObject(current$$1);
+          newProps = current$$1.stateNode;
+          newProps.pendingContext &&
+            ((newProps.context = newProps.pendingContext),
+            (newProps.pendingContext = null));
+          if (null === current || null === current.child)
+            current$$1.effectTag &= -3;
+          updateHostContainer(current$$1);
+          break;
+        case 5:
+          popHostContext(current$$1);
+          var rootContainerInstance = requiredContext(
+              rootInstanceStackCursor.current
+            ),
+            type = current$$1.type;
+          if (null !== current && null != current$$1.stateNode) {
+            var oldProps = current.memoizedProps,
+              currentHostContext = requiredContext(
+                contextStackCursor$1.current
+              );
+            updateHostComponent$1(
+              current,
+              current$$1,
+              UPDATE_SIGNAL,
+              type,
+              oldProps,
+              newProps,
+              rootContainerInstance,
+              currentHostContext
+            );
+            current.ref !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else if (newProps) {
+            current = requiredContext(contextStackCursor$1.current);
+            var type$jscomp$0 = type;
+            oldProps = newProps;
+            var rootContainerInstance$jscomp$0 = rootContainerInstance,
+              hostContext = current;
+            currentHostContext = current$$1;
+            var tag = allocateTag(),
+              viewConfig = ReactNativeViewConfigRegistry.get(type$jscomp$0);
+            invariant(
+              "RCTView" !== type$jscomp$0 || !hostContext.isInAParentText,
+              "Nesting of <View> within <Text> is not currently supported."
+            );
+            type$jscomp$0 = diffProperties(
+              null,
+              emptyObject,
+              oldProps,
+              viewConfig.validAttributes
+            );
+            UIManager.createView(
+              tag,
+              viewConfig.uiViewClassName,
+              rootContainerInstance$jscomp$0,
+              type$jscomp$0
+            );
+            rootContainerInstance$jscomp$0 = new ReactNativeFiberHostComponent(
+              tag,
+              viewConfig
+            );
+            instanceCache[tag] = currentHostContext;
+            instanceProps[tag] = oldProps;
+            oldProps = rootContainerInstance$jscomp$0;
+            a: for (
+              currentHostContext = oldProps,
+                tag = current$$1,
+                rootContainerInstance$jscomp$0 = tag.child;
+              null !== rootContainerInstance$jscomp$0;
+
+            ) {
+              if (
+                5 === rootContainerInstance$jscomp$0.tag ||
+                6 === rootContainerInstance$jscomp$0.tag
+              )
+                currentHostContext._children.push(
+                  rootContainerInstance$jscomp$0.stateNode
+                );
+              else if (
+                4 !== rootContainerInstance$jscomp$0.tag &&
+                null !== rootContainerInstance$jscomp$0.child
+              ) {
+                rootContainerInstance$jscomp$0.child.return = rootContainerInstance$jscomp$0;
+                rootContainerInstance$jscomp$0 =
+                  rootContainerInstance$jscomp$0.child;
+                continue;
+              }
+              if (rootContainerInstance$jscomp$0 === tag) break;
+              for (; null === rootContainerInstance$jscomp$0.sibling; ) {
+                if (
+                  null === rootContainerInstance$jscomp$0.return ||
+                  rootContainerInstance$jscomp$0.return === tag
+                )
+                  break a;
+                rootContainerInstance$jscomp$0 =
+                  rootContainerInstance$jscomp$0.return;
+              }
+              rootContainerInstance$jscomp$0.sibling.return =
+                rootContainerInstance$jscomp$0.return;
+              rootContainerInstance$jscomp$0 =
+                rootContainerInstance$jscomp$0.sibling;
+            }
+            finalizeInitialChildren(
+              oldProps,
+              type,
+              newProps,
+              rootContainerInstance,
+              current
+            ) && (current$$1.effectTag |= 4);
+            current$$1.stateNode = oldProps;
+            null !== current$$1.ref && (current$$1.effectTag |= 128);
+          } else
+            invariant(
+              null !== current$$1.stateNode,
+              "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+            );
+          break;
+        case 6:
+          type = newProps;
+          current && null != current$$1.stateNode
+            ? updateHostText$1(current, current$$1, current.memoizedProps, type)
+            : ("string" !== typeof type &&
+                invariant(
+                  null !== current$$1.stateNode,
+                  "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."
+                ),
+              (current = requiredContext(rootInstanceStackCursor.current)),
+              (rootContainerInstance = requiredContext(
+                contextStackCursor$1.current
+              )),
+              (oldProps = newProps = current$$1),
+              invariant(
+                rootContainerInstance.isInAParentText,
+                "Text strings must be rendered within a <Text> component."
+              ),
+              (rootContainerInstance = allocateTag()),
+              UIManager.createView(
+                rootContainerInstance,
+                "RCTRawText",
+                current,
+                { text: type }
+              ),
+              (instanceCache[rootContainerInstance] = oldProps),
+              (newProps.stateNode = rootContainerInstance));
+          break;
+        case 14:
+          break;
+        case 16:
+          break;
+        case 10:
+          break;
+        case 11:
+          break;
+        case 15:
+          break;
+        case 4:
+          popHostContainer(current$$1);
+          updateHostContainer(current$$1);
+          break;
+        case 13:
+          popProvider(current$$1);
+          break;
+        case 12:
+          break;
+        case 0:
+          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."
+          );
+      }
+      current$$1.mode & 4 && recordElapsedActualRenderTime(current$$1);
+      current$$1 = nextUnitOfWork = null;
+      newProps = workInProgress;
       if (
         1073741823 === nextRenderExpirationTime ||
-        1073741823 !== workInProgress.expirationTime
+        1073741823 !== newProps.childExpirationTime
       ) {
-        var newExpirationTime = 0;
-        switch (workInProgress.tag) {
-          case 3:
-          case 2:
-            var updateQueue = workInProgress.updateQueue;
-            null !== updateQueue &&
-              (newExpirationTime = updateQueue.expirationTime);
-        }
-        if (workInProgress.mode & 4) {
-          updateQueue = workInProgress.selfBaseTime;
-          for (var child = workInProgress.child; null !== child; )
-            (updateQueue += child.treeBaseTime),
-              0 !== child.expirationTime &&
-                (0 === newExpirationTime ||
-                  newExpirationTime > child.expirationTime) &&
-                (newExpirationTime = child.expirationTime),
-              (child = child.sibling);
-          workInProgress.treeBaseTime = updateQueue;
+        rootContainerInstance = 0;
+        if (newProps.mode & 4) {
+          type = newProps.selfBaseDuration;
+          for (current = newProps.child; null !== current; ) {
+            oldProps = current.expirationTime;
+            currentHostContext = current.childExpirationTime;
+            if (
+              0 === rootContainerInstance ||
+              (0 !== oldProps && oldProps < rootContainerInstance)
+            )
+              rootContainerInstance = oldProps;
+            if (
+              0 === rootContainerInstance ||
+              (0 !== currentHostContext &&
+                currentHostContext < rootContainerInstance)
+            )
+              rootContainerInstance = currentHostContext;
+            type += current.treeBaseDuration;
+            current = current.sibling;
+          }
+          newProps.treeBaseDuration = type;
         } else
-          for (updateQueue = workInProgress.child; null !== updateQueue; )
-            0 !== updateQueue.expirationTime &&
-              (0 === newExpirationTime ||
-                newExpirationTime > updateQueue.expirationTime) &&
-              (newExpirationTime = updateQueue.expirationTime),
-              (updateQueue = updateQueue.sibling);
-        workInProgress.expirationTime = newExpirationTime;
+          for (type = newProps.child; null !== type; ) {
+            current = type.expirationTime;
+            oldProps = type.childExpirationTime;
+            if (
+              0 === rootContainerInstance ||
+              (0 !== current && current < rootContainerInstance)
+            )
+              rootContainerInstance = current;
+            if (
+              0 === rootContainerInstance ||
+              (0 !== oldProps && oldProps < rootContainerInstance)
+            )
+              rootContainerInstance = oldProps;
+            type = type.sibling;
+          }
+        newProps.childExpirationTime = rootContainerInstance;
       }
-      if (null !== current) return current;
+      if (null !== current$$1) return current$$1;
       null !== returnFiber &&
         0 === (returnFiber.effectTag & 512) &&
         (null === returnFiber.firstEffect &&
-          (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect),
-        null !== workInProgress$jscomp$0.lastEffect &&
+          (returnFiber.firstEffect = workInProgress.firstEffect),
+        null !== workInProgress.lastEffect &&
           (null !== returnFiber.lastEffect &&
-            (returnFiber.lastEffect.nextEffect =
-              workInProgress$jscomp$0.firstEffect),
-          (returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect)),
-        1 < workInProgress$jscomp$0.effectTag &&
+            (returnFiber.lastEffect.nextEffect = workInProgress.firstEffect),
+          (returnFiber.lastEffect = workInProgress.lastEffect)),
+        1 < workInProgress.effectTag &&
           (null !== returnFiber.lastEffect
-            ? (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0)
-            : (returnFiber.firstEffect = workInProgress$jscomp$0),
-          (returnFiber.lastEffect = workInProgress$jscomp$0)));
+            ? (returnFiber.lastEffect.nextEffect = workInProgress)
+            : (returnFiber.firstEffect = workInProgress),
+          (returnFiber.lastEffect = workInProgress)));
     } else {
-      workInProgress$jscomp$0 = unwindWork(
-        workInProgress$jscomp$0,
-        nextRenderExpirationTime
-      );
-      if (null !== workInProgress$jscomp$0)
-        return (
-          (workInProgress$jscomp$0.effectTag &= 511), workInProgress$jscomp$0
-        );
+      workInProgress = unwindWork(workInProgress, nextRenderExpirationTime);
+      if (null !== workInProgress)
+        return (workInProgress.effectTag &= 511), workInProgress;
       null !== returnFiber &&
         ((returnFiber.firstEffect = returnFiber.lastEffect = null),
         (returnFiber.effectTag |= 512));
     }
     if (null !== siblingFiber) return siblingFiber;
-    if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;
+    if (null !== returnFiber) workInProgress = returnFiber;
     else break;
   }
   return null;
 }
 function performUnitOfWork(workInProgress) {
-  var current = workInProgress.alternate;
+  var current$$1 = workInProgress.alternate;
   workInProgress.mode & 4 && (baseStartTime = now$1());
-  current = beginWork(current, workInProgress, nextRenderExpirationTime);
+  current$$1 = beginWork(current$$1, workInProgress, nextRenderExpirationTime);
   workInProgress.mode & 4 &&
     (-1 !== baseStartTime &&
-      (workInProgress.selfBaseTime = now$1() - baseStartTime),
+      (workInProgress.selfBaseDuration = now$1() - baseStartTime),
     (baseStartTime = -1));
-  null === current && (current = completeUnitOfWork(workInProgress));
-  ReactCurrentOwner.current = null;
-  return current;
+  null === current$$1 && (current$$1 = completeUnitOfWork(workInProgress));
+  ReactCurrentOwner$2.current = null;
+  return current$$1;
 }
-function renderRoot(root$jscomp$0, isYieldy) {
+function renderRoot(root, isYieldy, isExpired) {
   invariant(
     !isWorking,
     "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isWorking = !0;
-  var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
+  ReactCurrentOwner$2.currentDispatcher = Dispatcher;
+  var expirationTime = root.nextExpirationTimeToWorkOn;
   if (
     expirationTime !== nextRenderExpirationTime ||
-    root$jscomp$0 !== nextRoot ||
+    root !== nextRoot ||
     null === nextUnitOfWork
   )
     resetStack(),
-      (nextRoot = root$jscomp$0),
+      (nextRoot = root),
       (nextRenderExpirationTime = expirationTime),
-      (nextLatestTimeoutMs = -1),
-      (nextRenderDidError = !1),
       (nextUnitOfWork = createWorkInProgress(
         nextRoot.current,
         null,
         nextRenderExpirationTime
       )),
-      (root$jscomp$0.pendingCommitExpirationTime = 0);
+      (root.pendingCommitExpirationTime = 0);
   var didFatal = !1;
   do {
     try {
       if (isYieldy) {
         for (; null !== nextUnitOfWork && !shouldYield(); )
           nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
-        0 === timerPausedAt && (timerPausedAt = now$1());
+        pauseActualRenderTimerIfRunning();
       } else
         for (; null !== nextUnitOfWork; )
           nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
@@ -4743,110 +4905,117 @@ function renderRoot(root$jscomp$0, isYieldy) {
           null !== nextUnitOfWork,
           "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it."
         );
-        isYieldy = nextUnitOfWork;
-        var returnFiber = isYieldy.return;
-        if (null === returnFiber) {
-          didFatal = !0;
-          onUncaughtError(thrownValue);
-          break;
-        }
-        a: {
-          var root = root$jscomp$0,
-            returnFiber$jscomp$0 = returnFiber,
-            sourceFiber = isYieldy,
-            value = thrownValue;
-          returnFiber = nextRenderExpirationTime;
-          sourceFiber.effectTag |= 512;
-          sourceFiber.firstEffect = sourceFiber.lastEffect = null;
-          nextRenderDidError = !0;
-          if (
-            (root.didError || 1 === returnFiber) &&
-            (returnFiber === root.latestPendingTime ||
-              returnFiber === root.latestSuspendedTime)
-          ) {
-            value = createCapturedValue(value, sourceFiber);
-            root = returnFiber$jscomp$0;
+        var sourceFiber = nextUnitOfWork,
+          returnFiber = sourceFiber.return;
+        if (null === returnFiber) (didFatal = !0), onUncaughtError(thrownValue);
+        else {
+          a: {
+            var returnFiber$jscomp$0 = returnFiber,
+              sourceFiber$jscomp$0 = sourceFiber,
+              value = thrownValue;
+            returnFiber = nextRenderExpirationTime;
+            sourceFiber$jscomp$0.effectTag |= 512;
+            sourceFiber$jscomp$0.firstEffect = sourceFiber$jscomp$0.lastEffect = null;
+            nextRenderDidError = !0;
+            value = createCapturedValue(value, sourceFiber$jscomp$0);
             do {
-              switch (root.tag) {
+              switch (returnFiber$jscomp$0.tag) {
                 case 3:
-                  root.effectTag |= 1024;
-                  value = createRootErrorUpdate(root, value, returnFiber);
-                  enqueueCapturedUpdate(root, value, returnFiber);
+                  returnFiber$jscomp$0.effectTag |= 1024;
+                  returnFiber$jscomp$0.expirationTime = returnFiber;
+                  returnFiber = createRootErrorUpdate(
+                    returnFiber$jscomp$0,
+                    value,
+                    returnFiber
+                  );
+                  enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                   break a;
                 case 2:
+                  sourceFiber$jscomp$0 = value;
+                  var instance = returnFiber$jscomp$0.stateNode;
                   if (
-                    ((returnFiber$jscomp$0 = value),
-                    (sourceFiber = root.stateNode),
-                    0 === (root.effectTag & 64) &&
-                      null !== sourceFiber &&
-                      "function" === typeof sourceFiber.componentDidCatch &&
-                      (null === legacyErrorBoundariesThatAlreadyFailed ||
-                        !legacyErrorBoundariesThatAlreadyFailed.has(
-                          sourceFiber
-                        )))
+                    0 === (returnFiber$jscomp$0.effectTag & 64) &&
+                    null !== instance &&
+                    "function" === typeof instance.componentDidCatch &&
+                    (null === legacyErrorBoundariesThatAlreadyFailed ||
+                      !legacyErrorBoundariesThatAlreadyFailed.has(instance))
                   ) {
-                    root.effectTag |= 1024;
-                    value = createClassErrorUpdate(
-                      root,
+                    returnFiber$jscomp$0.effectTag |= 1024;
+                    returnFiber$jscomp$0.expirationTime = returnFiber;
+                    returnFiber = createClassErrorUpdate(
                       returnFiber$jscomp$0,
+                      sourceFiber$jscomp$0,
                       returnFiber
                     );
-                    enqueueCapturedUpdate(root, value, returnFiber);
+                    enqueueCapturedUpdate(returnFiber$jscomp$0, returnFiber);
                     break a;
                   }
               }
-              root = root.return;
-            } while (null !== root);
+              returnFiber$jscomp$0 = returnFiber$jscomp$0.return;
+            } while (null !== returnFiber$jscomp$0);
           }
+          nextUnitOfWork = completeUnitOfWork(sourceFiber);
+          continue;
         }
-        nextUnitOfWork = completeUnitOfWork(isYieldy);
       }
     }
     break;
   } while (1);
   isWorking = !1;
-  didFatal
-    ? (root$jscomp$0.finishedWork = null)
-    : null === nextUnitOfWork
-      ? ((didFatal = root$jscomp$0.current.alternate),
-        invariant(
-          null !== didFatal,
-          "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
-        ),
-        0 === (didFatal.effectTag & 512)
-          ? ((root$jscomp$0.pendingCommitExpirationTime = expirationTime),
-            (root$jscomp$0.finishedWork = didFatal))
-          : (!nextRenderDidError ||
-            (expirationTime !== root$jscomp$0.latestPendingTime &&
-              expirationTime !== root$jscomp$0.latestSuspendedTime)
-              ? ((didFatal = root$jscomp$0.earliestPendingTime),
-                (isYieldy = root$jscomp$0.latestPendingTime),
-                didFatal === expirationTime
-                  ? (root$jscomp$0.earliestPendingTime =
-                      isYieldy === expirationTime
-                        ? (root$jscomp$0.latestPendingTime = 0)
-                        : isYieldy)
-                  : isYieldy === expirationTime &&
-                    (root$jscomp$0.latestPendingTime = didFatal),
-                (didFatal = root$jscomp$0.latestSuspendedTime),
-                didFatal === expirationTime &&
-                  (root$jscomp$0.latestPingedTime = 0),
-                (isYieldy = root$jscomp$0.earliestSuspendedTime),
-                0 === isYieldy
-                  ? (root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime)
-                  : isYieldy > expirationTime
-                    ? (root$jscomp$0.earliestSuspendedTime = expirationTime)
-                    : didFatal < expirationTime &&
-                      (root$jscomp$0.latestSuspendedTime = expirationTime))
-              : (root$jscomp$0.didError = !0),
-            findNextPendingPriorityLevel(root$jscomp$0),
-            onSuspend(
-              root$jscomp$0,
-              expirationTime,
-              root$jscomp$0.expirationTime,
-              nextLatestTimeoutMs
-            )))
-      : (root$jscomp$0.finishedWork = null);
+  lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = ReactCurrentOwner$2.currentDispatcher = null;
+  if (didFatal) (nextRoot = null), (root.finishedWork = null);
+  else if (null !== nextUnitOfWork) root.finishedWork = null;
+  else {
+    isYieldy = root.current.alternate;
+    invariant(
+      null !== isYieldy,
+      "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."
+    );
+    nextRoot = null;
+    if (nextRenderDidError) {
+      didFatal = root.latestPendingTime;
+      sourceFiber = root.latestSuspendedTime;
+      returnFiber = root.latestPingedTime;
+      if (
+        (0 !== didFatal && didFatal > expirationTime) ||
+        (0 !== sourceFiber && sourceFiber > expirationTime) ||
+        (0 !== returnFiber && returnFiber > expirationTime)
+      ) {
+        root.didError = !1;
+        isExpired = root.latestPingedTime;
+        0 !== isExpired &&
+          isExpired <= expirationTime &&
+          (root.latestPingedTime = 0);
+        isExpired = root.earliestPendingTime;
+        isYieldy = root.latestPendingTime;
+        isExpired === expirationTime
+          ? (root.earliestPendingTime =
+              isYieldy === expirationTime
+                ? (root.latestPendingTime = 0)
+                : isYieldy)
+          : isYieldy === expirationTime && (root.latestPendingTime = isExpired);
+        isExpired = root.earliestSuspendedTime;
+        isYieldy = root.latestSuspendedTime;
+        0 === isExpired
+          ? (root.earliestSuspendedTime = root.latestSuspendedTime = expirationTime)
+          : isExpired > expirationTime
+            ? (root.earliestSuspendedTime = expirationTime)
+            : isYieldy < expirationTime &&
+              (root.latestSuspendedTime = expirationTime);
+        findNextExpirationTimeToWorkOn(expirationTime, root);
+        root.expirationTime = root.expirationTime;
+        return;
+      }
+      if (!root.didError && !isExpired) {
+        root.didError = !0;
+        root.nextExpirationTimeToWorkOn = expirationTime;
+        root.expirationTime = 1;
+        return;
+      }
+    }
+    root.pendingCommitExpirationTime = expirationTime;
+    root.finishedWork = isYieldy;
+  }
 }
 function captureCommitPhaseError(fiber, error) {
   var JSCompiler_inline_result;
@@ -4872,7 +5041,7 @@ function captureCommitPhaseError(fiber, error) {
           ) {
             fiber = createCapturedValue(error, fiber);
             fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
-            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+            enqueueUpdate(JSCompiler_inline_result, fiber);
             scheduleWork(JSCompiler_inline_result, 1);
             JSCompiler_inline_result = void 0;
             break a;
@@ -4881,7 +5050,7 @@ function captureCommitPhaseError(fiber, error) {
         case 3:
           fiber = createCapturedValue(error, fiber);
           fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
-          enqueueUpdate(JSCompiler_inline_result, fiber, 1);
+          enqueueUpdate(JSCompiler_inline_result, fiber);
           scheduleWork(JSCompiler_inline_result, 1);
           JSCompiler_inline_result = void 0;
           break a;
@@ -4895,23 +5064,25 @@ function captureCommitPhaseError(fiber, error) {
         JSCompiler_inline_result,
         1
       )),
-      enqueueUpdate(fiber, JSCompiler_inline_result, 1),
+      enqueueUpdate(fiber, JSCompiler_inline_result),
       scheduleWork(fiber, 1));
     JSCompiler_inline_result = void 0;
   }
   return JSCompiler_inline_result;
 }
 function computeExpirationForFiber(currentTime, fiber) {
-  currentTime =
-    0 !== expirationContext
-      ? expirationContext
-      : isWorking
-        ? isCommitting$1 ? 1 : nextRenderExpirationTime
-        : fiber.mode & 1
-          ? isBatchingInteractiveUpdates
+  0 !== expirationContext
+    ? (currentTime = expirationContext)
+    : isWorking
+      ? (currentTime = isCommitting$1 ? 1 : nextRenderExpirationTime)
+      : fiber.mode & 1
+        ? ((currentTime = isBatchingInteractiveUpdates
             ? 2 + 10 * ((((currentTime - 2 + 15) / 10) | 0) + 1)
-            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)
-          : 1;
+            : 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1)),
+          null !== nextRoot &&
+            currentTime === nextRenderExpirationTime &&
+            (currentTime += 1))
+        : (currentTime = 1);
   isBatchingInteractiveUpdates &&
     (0 === lowestPendingInteractiveExpirationTime ||
       currentTime > lowestPendingInteractiveExpirationTime) &&
@@ -4919,35 +5090,51 @@ function computeExpirationForFiber(currentTime, fiber) {
   return currentTime;
 }
 function scheduleWork(fiber, expirationTime) {
-  for (; null !== fiber; ) {
+  a: {
     if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime)
       fiber.expirationTime = expirationTime;
-    null !== fiber.alternate &&
-      (0 === fiber.alternate.expirationTime ||
-        fiber.alternate.expirationTime > expirationTime) &&
-      (fiber.alternate.expirationTime = expirationTime);
-    if (null === fiber.return)
-      if (3 === fiber.tag) {
-        var root = fiber.stateNode;
-        !isWorking &&
-          0 !== nextRenderExpirationTime &&
-          expirationTime < nextRenderExpirationTime &&
-          resetStack();
-        markPendingPriorityLevel(root, expirationTime);
-        (isWorking && !isCommitting$1 && nextRoot === root) ||
-          requestWork(root, root.expirationTime);
-        nestedUpdateCount > NESTED_UPDATE_LIMIT &&
-          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."
-          );
-      } else break;
-    fiber = fiber.return;
+    var alternate = fiber.alternate;
+    null !== alternate &&
+      (0 === alternate.expirationTime ||
+        alternate.expirationTime > expirationTime) &&
+      (alternate.expirationTime = expirationTime);
+    var node = fiber.return;
+    if (null === node && 3 === fiber.tag) fiber = fiber.stateNode;
+    else {
+      for (; null !== node; ) {
+        alternate = node.alternate;
+        if (
+          0 === node.childExpirationTime ||
+          node.childExpirationTime > expirationTime
+        )
+          node.childExpirationTime = expirationTime;
+        null !== alternate &&
+          (0 === alternate.childExpirationTime ||
+            alternate.childExpirationTime > expirationTime) &&
+          (alternate.childExpirationTime = expirationTime);
+        if (null === node.return && 3 === node.tag) {
+          fiber = node.stateNode;
+          break a;
+        }
+        node = node.return;
+      }
+      fiber = null;
+    }
   }
-}
-function recalculateCurrentTime() {
-  mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
-  return (mostRecentCurrentTime = ((mostRecentCurrentTimeMs / 10) | 0) + 2);
+  null !== fiber &&
+    (!isWorking &&
+      0 !== nextRenderExpirationTime &&
+      expirationTime < nextRenderExpirationTime &&
+      resetStack(),
+    markPendingPriorityLevel(fiber, expirationTime),
+    (isWorking && !isCommitting$1 && nextRoot === fiber) ||
+      requestWork(fiber, fiber.expirationTime),
+    nestedUpdateCount > NESTED_UPDATE_LIMIT &&
+      ((nestedUpdateCount = 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."
+      )));
 }
 function syncUpdates(fn, a, b, c, d) {
   var previousExpirationContext = expirationContext;
@@ -4974,9 +5161,16 @@ var firstScheduledRoot = null,
   isUnbatchingUpdates = !1,
   isBatchingInteractiveUpdates = !1,
   completedBatches = null,
-  NESTED_UPDATE_LIMIT = 1e3,
+  originalStartTimeMs = now$1(),
+  currentRendererTime = ((originalStartTimeMs / 10) | 0) + 2,
+  currentSchedulerTime = currentRendererTime,
+  NESTED_UPDATE_LIMIT = 50,
   nestedUpdateCount = 0,
+  lastCommittedRootDuringThisBatch = null,
   timeHeuristicForUnitOfWork = 1;
+function recomputeCurrentRendererTime() {
+  currentRendererTime = (((now$1() - originalStartTimeMs) / 10) | 0) + 2;
+}
 function scheduleCallbackWithExpirationTime(expirationTime) {
   if (0 !== callbackExpirationTime) {
     if (expirationTime > callbackExpirationTime) return;
@@ -4991,21 +5185,16 @@ function scheduleCallbackWithExpirationTime(expirationTime) {
   scheduledCallback = performAsyncWork;
   callbackID = setTimeout(setTimeoutCallback, 1);
 }
-function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
-  0 <= timeoutMs &&
-    setTimeout(function() {
-      var latestSuspendedTime = root.latestSuspendedTime;
-      0 !== latestSuspendedTime &&
-        latestSuspendedTime <= suspendedExpirationTime &&
-        ((latestSuspendedTime = root.latestPingedTime),
-        0 === latestSuspendedTime ||
-          latestSuspendedTime < suspendedExpirationTime) &&
-        (root.latestPingedTime = suspendedExpirationTime);
-      findNextPendingPriorityLevel(root);
-      latestSuspendedTime = root.expirationTime;
-      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
-    }, timeoutMs);
-  root.expirationTime = expirationTime;
+function requestCurrentTime() {
+  if (isRendering) return currentSchedulerTime;
+  findHighestPriorityRoot();
+  if (
+    0 === nextFlushedExpirationTime ||
+    1073741823 === nextFlushedExpirationTime
+  )
+    recomputeCurrentRendererTime(),
+      (currentSchedulerTime = currentRendererTime);
+  return currentSchedulerTime;
 }
 function requestWork(root, expirationTime) {
   if (null === root.nextScheduledRoot)
@@ -5028,7 +5217,7 @@ function requestWork(root, expirationTime) {
       ? isUnbatchingUpdates &&
         ((nextFlushedRoot = root),
         (nextFlushedExpirationTime = 1),
-        performWorkOnRoot(root, 1, !1))
+        performWorkOnRoot(root, 1, !0))
       : 1 === expirationTime
         ? performWork(1, null)
         : scheduleCallbackWithExpirationTime(expirationTime));
@@ -5077,12 +5266,6 @@ function findHighestPriorityRoot() {
         root = root.nextScheduledRoot;
       }
     }
-  previousScheduledRoot = nextFlushedRoot;
-  null !== previousScheduledRoot &&
-  previousScheduledRoot === highestPriorityRoot &&
-  1 === highestPriorityWork
-    ? nestedUpdateCount++
-    : (nestedUpdateCount = 0);
   nextFlushedRoot = highestPriorityRoot;
   nextFlushedExpirationTime = highestPriorityWork;
 }
@@ -5092,21 +5275,26 @@ function performAsyncWork(dl) {
 function performWork(minExpirationTime, dl) {
   deadline = dl;
   findHighestPriorityRoot();
-  resumeActualRenderTimerIfPaused();
+  resumeActualRenderTimerIfPaused(1 === minExpirationTime);
   if (null !== deadline)
     for (
-      ;
+      recomputeCurrentRendererTime(),
+        currentSchedulerTime = currentRendererTime;
       null !== nextFlushedRoot &&
       0 !== nextFlushedExpirationTime &&
       (0 === minExpirationTime ||
         minExpirationTime >= nextFlushedExpirationTime) &&
-      (!deadlineDidExpire ||
-        recalculateCurrentTime() >= nextFlushedExpirationTime);
+      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime);
 
     )
-      recalculateCurrentTime(),
-        performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
-        findHighestPriorityRoot();
+      performWorkOnRoot(
+        nextFlushedRoot,
+        nextFlushedExpirationTime,
+        currentRendererTime >= nextFlushedExpirationTime
+      ),
+        findHighestPriorityRoot(),
+        recomputeCurrentRendererTime(),
+        (currentSchedulerTime = currentRendererTime);
   else
     for (
       ;
@@ -5116,22 +5304,22 @@ function performWork(minExpirationTime, dl) {
         minExpirationTime >= nextFlushedExpirationTime);
 
     )
-      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1),
+      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0),
         findHighestPriorityRoot();
   null !== deadline && ((callbackExpirationTime = 0), (callbackID = null));
   0 !== nextFlushedExpirationTime &&
     scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
   deadline = null;
   deadlineDidExpire = !1;
-  finishRendering();
-}
-function finishRendering() {
   nestedUpdateCount = 0;
-  if (null !== completedBatches) {
-    var batches = completedBatches;
-    completedBatches = null;
-    for (var i = 0; i < batches.length; i++) {
-      var batch = batches[i];
+  lastCommittedRootDuringThisBatch = null;
+  if (null !== completedBatches)
+    for (
+      minExpirationTime = completedBatches, completedBatches = null, dl = 0;
+      dl < minExpirationTime.length;
+      dl++
+    ) {
+      var batch = minExpirationTime[dl];
       try {
         batch._onComplete();
       } catch (error) {
@@ -5139,38 +5327,39 @@ function finishRendering() {
           ((hasUnhandledError = !0), (unhandledError = error));
       }
     }
-  }
   if (hasUnhandledError)
-    throw ((batches = unhandledError),
+    throw ((minExpirationTime = unhandledError),
     (unhandledError = null),
     (hasUnhandledError = !1),
-    batches);
+    minExpirationTime);
 }
-function performWorkOnRoot(root, expirationTime, isYieldy) {
+function performWorkOnRoot(root, expirationTime, isExpired) {
   invariant(
     !isRendering,
     "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue."
   );
   isRendering = !0;
-  isYieldy
-    ? ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot(root, isYieldy, expirationTime)
+  if (null === deadline || isExpired) {
+    var finishedWork = root.finishedWork;
+    null !== finishedWork
+      ? completeRoot(root, finishedWork, expirationTime)
+      : ((root.finishedWork = null),
+        renderRoot(root, !1, isExpired),
+        (finishedWork = root.finishedWork),
+        null !== finishedWork &&
+          completeRoot(root, finishedWork, expirationTime));
+  } else
+    (finishedWork = root.finishedWork),
+      null !== finishedWork
+        ? completeRoot(root, finishedWork, expirationTime)
         : ((root.finishedWork = null),
-          renderRoot(root, !0),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy &&
+          renderRoot(root, !0, isExpired),
+          (finishedWork = root.finishedWork),
+          null !== finishedWork &&
             (shouldYield()
-              ? ((root.finishedWork = isYieldy),
-                0 === timerPausedAt && (timerPausedAt = now$1()))
-              : completeRoot(root, isYieldy, expirationTime))))
-    : ((isYieldy = root.finishedWork),
-      null !== isYieldy
-        ? completeRoot(root, isYieldy, expirationTime)
-        : ((root.finishedWork = null),
-          renderRoot(root, !1),
-          (isYieldy = root.finishedWork),
-          null !== isYieldy && completeRoot(root, isYieldy, expirationTime)));
+              ? ((root.finishedWork = finishedWork),
+                pauseActualRenderTimerIfRunning())
+              : completeRoot(root, finishedWork, expirationTime)));
   isRendering = !1;
 }
 function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
@@ -5188,6 +5377,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
     return;
   }
   root.finishedWork = null;
+  root === lastCommittedRootDuringThisBatch
+    ? nestedUpdateCount++
+    : ((lastCommittedRootDuringThisBatch = root), (nestedUpdateCount = 0));
   isCommitting$1 = isWorking = !0;
   invariant(
     root.current !== finishedWork$jscomp$0,
@@ -5200,34 +5392,39 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
   );
   root.pendingCommitExpirationTime = 0;
   firstBatch = finishedWork$jscomp$0.expirationTime;
-  recalculateCurrentTime();
+  var childExpirationTimeBeforeCommit =
+    finishedWork$jscomp$0.childExpirationTime;
+  firstBatch =
+    0 === firstBatch ||
+    (0 !== childExpirationTimeBeforeCommit &&
+      childExpirationTimeBeforeCommit < firstBatch)
+      ? childExpirationTimeBeforeCommit
+      : firstBatch;
   root.didError = !1;
-  if (0 === firstBatch)
-    (root.earliestPendingTime = 0),
+  0 === firstBatch
+    ? ((root.earliestPendingTime = 0),
       (root.latestPendingTime = 0),
       (root.earliestSuspendedTime = 0),
       (root.latestSuspendedTime = 0),
-      (root.latestPingedTime = 0);
-  else {
-    var latestPendingTime = root.latestPendingTime;
-    0 !== latestPendingTime &&
-      (latestPendingTime < firstBatch
-        ? (root.earliestPendingTime = root.latestPendingTime = 0)
-        : root.earliestPendingTime < firstBatch &&
-          (root.earliestPendingTime = root.latestPendingTime));
-    latestPendingTime = root.earliestSuspendedTime;
-    0 === latestPendingTime
-      ? markPendingPriorityLevel(root, firstBatch)
-      : firstBatch > root.latestSuspendedTime
-        ? ((root.earliestSuspendedTime = 0),
-          (root.latestSuspendedTime = 0),
-          (root.latestPingedTime = 0),
-          markPendingPriorityLevel(root, firstBatch))
-        : firstBatch < latestPendingTime &&
-          markPendingPriorityLevel(root, firstBatch);
-  }
-  findNextPendingPriorityLevel(root);
-  ReactCurrentOwner.current = null;
+      (root.latestPingedTime = 0))
+    : ((childExpirationTimeBeforeCommit = root.latestPendingTime),
+      0 !== childExpirationTimeBeforeCommit &&
+        (childExpirationTimeBeforeCommit < firstBatch
+          ? (root.earliestPendingTime = root.latestPendingTime = 0)
+          : root.earliestPendingTime < firstBatch &&
+            (root.earliestPendingTime = root.latestPendingTime)),
+      (childExpirationTimeBeforeCommit = root.earliestSuspendedTime),
+      0 === childExpirationTimeBeforeCommit
+        ? markPendingPriorityLevel(root, firstBatch)
+        : firstBatch > root.latestSuspendedTime
+          ? ((root.earliestSuspendedTime = 0),
+            (root.latestSuspendedTime = 0),
+            (root.latestPingedTime = 0),
+            markPendingPriorityLevel(root, firstBatch))
+          : firstBatch < childExpirationTimeBeforeCommit &&
+            markPendingPriorityLevel(root, firstBatch));
+  findNextExpirationTimeToWorkOn(0, root);
+  ReactCurrentOwner$2.current = null;
   1 < finishedWork$jscomp$0.effectTag
     ? null !== finishedWork$jscomp$0.lastEffect
       ? ((finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0),
@@ -5235,18 +5432,18 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
       : (firstBatch = finishedWork$jscomp$0)
     : (firstBatch = finishedWork$jscomp$0.firstEffect);
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    latestPendingTime = !1;
+    childExpirationTimeBeforeCommit = !1;
     var error = void 0;
     try {
       for (; null !== nextEffect; ) {
         if (nextEffect.effectTag & 256) {
-          var current = nextEffect.alternate,
+          var current$$1 = nextEffect.alternate,
             finishedWork = nextEffect;
           switch (finishedWork.tag) {
             case 2:
-              if (finishedWork.effectTag & 256 && null !== current) {
-                var prevProps = current.memoizedProps,
-                  prevState = current.memoizedState,
+              if (finishedWork.effectTag & 256 && null !== current$$1) {
+                var prevProps = current$$1.memoizedProps,
+                  prevState = current$$1.memoizedState,
                   instance = finishedWork.stateNode;
                 instance.props = finishedWork.memoizedProps;
                 instance.state = finishedWork.memoizedState;
@@ -5272,9 +5469,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (latestPendingTime = !0), (error = e);
+      (childExpirationTimeBeforeCommit = !0), (error = e);
     }
-    latestPendingTime &&
+    childExpirationTimeBeforeCommit &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5284,15 +5481,15 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
   }
   commitTime = now$1();
   for (nextEffect = firstBatch; null !== nextEffect; ) {
-    current = !1;
+    current$$1 = !1;
     prevProps = void 0;
     try {
       for (; null !== nextEffect; ) {
         var effectTag = nextEffect.effectTag;
         if (effectTag & 128) {
-          var current$jscomp$0 = nextEffect.alternate;
-          if (null !== current$jscomp$0) {
-            var currentRef = current$jscomp$0.ref;
+          var current$$1$jscomp$0 = nextEffect.alternate;
+          if (null !== current$$1$jscomp$0) {
+            var currentRef = current$$1$jscomp$0.ref;
             null !== currentRef &&
               ("function" === typeof currentRef
                 ? currentRef(null)
@@ -5324,9 +5521,9 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = nextEffect.nextEffect;
       }
     } catch (e) {
-      (current = !0), (prevProps = e);
+      (current$$1 = !0), (prevProps = e);
     }
-    current &&
+    current$$1 &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
@@ -5337,57 +5534,62 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
   root.current = finishedWork$jscomp$0;
   for (nextEffect = firstBatch; null !== nextEffect; ) {
     effectTag = !1;
-    current$jscomp$0 = void 0;
+    current$$1$jscomp$0 = void 0;
     try {
       for (currentRef = expirationTime; null !== nextEffect; ) {
         var effectTag$jscomp$0 = nextEffect.effectTag;
         if (effectTag$jscomp$0 & 36) {
-          var current$jscomp$1 = nextEffect.alternate;
-          current = nextEffect;
+          var current$$1$jscomp$1 = nextEffect.alternate;
+          current$$1 = nextEffect;
           prevProps = currentRef;
-          switch (current.tag) {
+          switch (current$$1.tag) {
             case 2:
-              var instance$jscomp$0 = current.stateNode;
-              if (current.effectTag & 4)
-                if (null === current$jscomp$1)
-                  (instance$jscomp$0.props = current.memoizedProps),
-                    (instance$jscomp$0.state = current.memoizedState),
+              var instance$jscomp$0 = current$$1.stateNode;
+              if (current$$1.effectTag & 4)
+                if (null === current$$1$jscomp$1)
+                  (instance$jscomp$0.props = current$$1.memoizedProps),
+                    (instance$jscomp$0.state = current$$1.memoizedState),
                     instance$jscomp$0.componentDidMount();
                 else {
-                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
-                    prevState$jscomp$0 = current$jscomp$1.memoizedState;
-                  instance$jscomp$0.props = current.memoizedProps;
-                  instance$jscomp$0.state = current.memoizedState;
+                  var prevProps$jscomp$0 = current$$1$jscomp$1.memoizedProps,
+                    prevState$jscomp$0 = current$$1$jscomp$1.memoizedState;
+                  instance$jscomp$0.props = current$$1.memoizedProps;
+                  instance$jscomp$0.state = current$$1.memoizedState;
                   instance$jscomp$0.componentDidUpdate(
                     prevProps$jscomp$0,
                     prevState$jscomp$0,
                     instance$jscomp$0.__reactInternalSnapshotBeforeUpdate
                   );
                 }
-              var updateQueue = current.updateQueue;
+              var updateQueue = current$$1.updateQueue;
               null !== updateQueue &&
-                ((instance$jscomp$0.props = current.memoizedProps),
-                (instance$jscomp$0.state = current.memoizedState),
+                ((instance$jscomp$0.props = current$$1.memoizedProps),
+                (instance$jscomp$0.state = current$$1.memoizedState),
                 commitUpdateQueue(
-                  current,
+                  current$$1,
                   updateQueue,
                   instance$jscomp$0,
                   prevProps
                 ));
               break;
             case 3:
-              var _updateQueue = current.updateQueue;
+              var _updateQueue = current$$1.updateQueue;
               if (null !== _updateQueue) {
                 prevState = null;
-                if (null !== current.child)
-                  switch (current.child.tag) {
+                if (null !== current$$1.child)
+                  switch (current$$1.child.tag) {
                     case 5:
-                      prevState = current.child.stateNode;
+                      prevState = current$$1.child.stateNode;
                       break;
                     case 2:
-                      prevState = current.child.stateNode;
+                      prevState = current$$1.child.stateNode;
                   }
-                commitUpdateQueue(current, _updateQueue, prevState, prevProps);
+                commitUpdateQueue(
+                  current$$1,
+                  _updateQueue,
+                  prevState,
+                  prevProps
+                );
               }
               break;
             case 5:
@@ -5408,18 +5610,20 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
           }
         }
         if (effectTag$jscomp$0 & 128) {
-          current = void 0;
+          current$$1 = void 0;
           var ref = nextEffect.ref;
           if (null !== ref) {
             var instance$jscomp$1 = nextEffect.stateNode;
             switch (nextEffect.tag) {
               case 5:
-                current = instance$jscomp$1;
+                current$$1 = instance$jscomp$1;
                 break;
               default:
-                current = instance$jscomp$1;
+                current$$1 = instance$jscomp$1;
             }
-            "function" === typeof ref ? ref(current) : (ref.current = current);
+            "function" === typeof ref
+              ? ref(current$$1)
+              : (ref.current = current$$1);
           }
         }
         var next = nextEffect.nextEffect;
@@ -5427,32 +5631,37 @@ function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
         nextEffect = next;
       }
     } catch (e) {
-      (effectTag = !0), (current$jscomp$0 = e);
+      (effectTag = !0), (current$$1$jscomp$0 = e);
     }
     effectTag &&
       (invariant(
         null !== nextEffect,
         "Should have next effect. This error is likely caused by a bug in React. Please file an issue."
       ),
-      captureCommitPhaseError(nextEffect, current$jscomp$0),
+      captureCommitPhaseError(nextEffect, current$$1$jscomp$0),
       null !== nextEffect && (nextEffect = nextEffect.nextEffect));
   }
-  totalElapsedPauseTime = 0;
   isWorking = isCommitting$1 = !1;
-  "function" === typeof onCommitRoot &&
-    onCommitRoot(finishedWork$jscomp$0.stateNode);
-  finishedWork$jscomp$0 = root.expirationTime;
+  "function" === typeof onCommitFiberRoot &&
+    onCommitFiberRoot(finishedWork$jscomp$0.stateNode);
+  effectTag$jscomp$0 = finishedWork$jscomp$0.expirationTime;
+  finishedWork$jscomp$0 = finishedWork$jscomp$0.childExpirationTime;
+  finishedWork$jscomp$0 =
+    0 === effectTag$jscomp$0 ||
+    (0 !== finishedWork$jscomp$0 && finishedWork$jscomp$0 < effectTag$jscomp$0)
+      ? finishedWork$jscomp$0
+      : effectTag$jscomp$0;
   0 === finishedWork$jscomp$0 &&
     (legacyErrorBoundariesThatAlreadyFailed = null);
   root.expirationTime = finishedWork$jscomp$0;
   root.finishedWork = null;
 }
 function shouldYield() {
-  return null === deadline ||
-    deadlineDidExpire ||
-    deadline.timeRemaining() > timeHeuristicForUnitOfWork
-    ? !1
-    : (deadlineDidExpire = !0);
+  return deadlineDidExpire
+    ? !0
+    : null === deadline || deadline.timeRemaining() > timeHeuristicForUnitOfWork
+      ? !1
+      : (deadlineDidExpire = !0);
 }
 function onUncaughtError(error) {
   invariant(
@@ -5469,7 +5678,7 @@ function updateContainerAtExpirationTime(
   expirationTime,
   callback
 ) {
-  var current = container.current;
+  var current$$1 = container.current;
   if (parentComponent) {
     parentComponent = parentComponent._reactInternalFiber;
     var parentContext;
@@ -5495,7 +5704,7 @@ function updateContainerAtExpirationTime(
     parentComponent = isContextProvider(parentComponent)
       ? processChildContext(parentComponent, parentContext)
       : parentContext;
-  } else parentComponent = emptyObject;
+  } else parentComponent = emptyContextObject;
   null === container.context
     ? (container.context = parentComponent)
     : (container.pendingContext = parentComponent);
@@ -5504,8 +5713,8 @@ function updateContainerAtExpirationTime(
   callback.payload = { element: element };
   container = void 0 === container ? null : container;
   null !== container && (callback.callback = container);
-  enqueueUpdate(current, callback, expirationTime);
-  scheduleWork(current, expirationTime);
+  enqueueUpdate(current$$1, callback);
+  scheduleWork(current$$1, expirationTime);
   return expirationTime;
 }
 function findHostInstance$1(component) {
@@ -5522,14 +5731,14 @@ function findHostInstance$1(component) {
   return null === component ? null : component.stateNode;
 }
 function updateContainer(element, container, parentComponent, callback) {
-  var current = container.current,
-    currentTime = recalculateCurrentTime();
-  current = computeExpirationForFiber(currentTime, current);
+  var current$$1 = container.current,
+    currentTime = requestCurrentTime();
+  current$$1 = computeExpirationForFiber(currentTime, current$$1);
   return updateContainerAtExpirationTime(
     element,
     container,
     parentComponent,
-    current,
+    current$$1,
     callback
   );
 }
@@ -5572,14 +5781,13 @@ var ReactNativeFiberRenderer = {
     );
     nextFlushedRoot = root;
     nextFlushedExpirationTime = expirationTime;
-    performWorkOnRoot(root, expirationTime, !1);
+    performWorkOnRoot(root, expirationTime, !0);
     performWork(1, null);
-    finishRendering();
+    pauseActualRenderTimerIfRunning();
   },
   requestWork: requestWork,
   computeUniqueAsyncExpiration: function() {
-    var result =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var result = 2 + 25 * ((((requestCurrentTime() - 2 + 500) / 25) | 0) + 1);
     result <= lastUniqueAsyncExpiration &&
       (result = lastUniqueAsyncExpiration + 1);
     return (lastUniqueAsyncExpiration = result);
@@ -5607,9 +5815,9 @@ var ReactNativeFiberRenderer = {
     return fn(a);
   },
   deferredUpdates: function(fn) {
-    var previousExpirationContext = expirationContext;
-    expirationContext =
-      2 + 25 * ((((recalculateCurrentTime() - 2 + 500) / 25) | 0) + 1);
+    var currentTime = requestCurrentTime(),
+      previousExpirationContext = expirationContext;
+    expirationContext = 2 + 25 * ((((currentTime - 2 + 500) / 25) | 0) + 1);
     try {
       return fn();
     } finally {
@@ -5781,7 +5989,7 @@ var roots = new Map(),
               maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
             nativeProps = diffProperties(
               null,
-              emptyObject$1,
+              emptyObject,
               nativeProps,
               viewConfig.validAttributes
             );
@@ -5857,7 +6065,7 @@ var roots = new Map(),
               var viewConfig = maybeInstance.viewConfig;
               nativeProps = diffProperties(
                 null,
-                emptyObject$1,
+                emptyObject,
                 nativeProps,
                 viewConfig.validAttributes
               );
@@ -5879,7 +6087,7 @@ var roots = new Map(),
       })(findNodeHandle, findHostInstance$1),
       computeComponentStackForErrorReporting: function(reactTag) {
         return (reactTag = getInstanceFromTag(reactTag))
-          ? getStackAddendumByWorkInProgressFiber(reactTag)
+          ? getStackByFiberInDevAndProd(reactTag)
           : "";
       }
     }
diff --git a/Libraries/Renderer/shims/ReactTypes.js b/Libraries/Renderer/shims/ReactTypes.js
index ac4eed362..bff9413c8 100644
--- a/Libraries/Renderer/shims/ReactTypes.js
+++ b/Libraries/Renderer/shims/ReactTypes.js
@@ -79,6 +79,7 @@ export type ReactContext<T> = {
   $$typeof: Symbol | number,
   Consumer: ReactContext<T>,
   Provider: ReactProviderType<T>,
+  unstable_read: () => T,
 
   _calculateChangedBits: ((a: T, b: T) => number) | null,
   _defaultValue: T,